Tests work again! 🎉

db/seeds.rb

@@ -7,10 +7,10 @@ if Rails.env == "development"
     ENV['OS_UPDATE_SERVER'] = "http://non_legacy_update_url.com"
     # CREDIT: Faker Ruby Gem
     VEGGIES                 = %w(artichoke arugula asparagus broccoli
-    cabbage caper carob carrot cauliflower celery chive cornichon cucumber
+    cabbage caper carrot cauliflower celery chive cornichon cucumber
     eggplant endive garlic jicama kale kohlrabi leek lettuce okra onion
     parsnip pepper potato pumpkin radicchio radish raspberry rhubarb spinach
-    sprout squash tomato turnip zucchini)
+     squash tomato turnip zucchini)
     [
       Sensor,
       Peripheral,

frontend/__tests__/i18next_failure_tests.ts

@@ -1,10 +1,8 @@
 jest.mock("axios", () => {
   return {
-    default: {
-      get: jest.fn((_url: string) => {
-        return Promise.reject("Simulated failure");
-      })
-    }
+    get: jest.fn((_url: string) => {
+      return Promise.reject("Simulated failure");
+    })
   };
 });
 

frontend/__tests__/i18next_test.ts

@@ -1,10 +1,8 @@
 jest.mock("axios", () => {
   return {
-    default: {
-      get: jest.fn((_url: string) => {
-        return Promise.resolve();
-      })
-    }
+    get: jest.fn((_url: string) => {
+      return Promise.resolve();
+    })
   };
 });
 import { generateUrl, getUserLang, generateI18nConfig } from "../i18n";

frontend/__tests__/refresh_token_no_test.ts

@@ -1,11 +1,12 @@
 jest.mock("axios", () => ({
-  default: {
-    interceptors: {
-      response: { use: jest.fn() },
-      request: { use: jest.fn() }
-    },
-    get() { return Promise.reject("NO"); }
+  interceptors: {
+    response: { use: jest.fn() },
+    request: { use: jest.fn() }
+  },
+  get() {
+    return Promise.reject("NO");
   }
+
 }));
 
 jest.mock("../session", () => ({ Session: { clear: jest.fn(), } }));

frontend/__tests__/refresh_token_ok_test.ts

@@ -6,14 +6,12 @@ const mockAuth = (iss = "987"): AuthState => ({
 });
 
 jest.mock("axios", () => ({
-  default: {
-    get() {
-      return Promise.resolve({ data: mockAuth("000") });
-    },
-    interceptors: {
-      response: { use: jest.fn() },
-      request: { use: jest.fn() }
-    }
+  get() {
+    return Promise.resolve({ data: mockAuth("000") });
+  },
+  interceptors: {
+    response: { use: jest.fn() },
+    request: { use: jest.fn() }
   }
 }));
 

frontend/account/__tests__/request_account_exports_test.ts

@@ -5,7 +5,7 @@ const mock = {
 };
 
 jest.mock("axios",
-  () => ({ default: { post: jest.fn(() => Promise.resolve(mock.response)) } }));
+  () => ({ post: jest.fn(() => Promise.resolve(mock.response)) }));
 
 import { API } from "../../api";
 import { Content } from "../../constants";

frontend/api/__tests__/crud_data_tracking.ts

@@ -5,11 +5,9 @@ jest.mock("../maybe_start_tracking", () => {
 const mockBody: Partial<TaggedUser["body"]> = { id: 23 };
 jest.mock("axios", () => {
   return {
-    default: {
-      delete: () => Promise.resolve({}),
-      post: () => Promise.resolve({ data: mockBody }),
-      put: () => Promise.resolve({ data: mockBody })
-    }
+    delete: () => Promise.resolve({}),
+    post: () => Promise.resolve({ data: mockBody }),
+    put: () => Promise.resolve({ data: mockBody })
   };
 });
 

frontend/api/__tests__/crud_malformed_data_tests.ts

@@ -7,10 +7,8 @@ jest.mock("../../device", () => ({
 }));
 
 jest.mock("axios", () => ({
-  default: {
-    get: () => { return Promise.resolve({ data: "" }); },
-    put: () => { return Promise.resolve({ data: "" }); },
-  }
+  get: () => { return Promise.resolve({ data: "" }); },
+  put: () => { return Promise.resolve({ data: "" }); },
 }));
 
 import { refresh, updateViaAjax } from "../crud";

frontend/api/__tests__/crud_success_tests.ts

@@ -1,16 +1,14 @@
 let mockPost = Promise.resolve({ data: { id: 1 } });
 jest.mock("axios", () => ({
-  default: {
-    get: () => Promise.resolve({
-      data: {
-        "id": 6,
-        "name": "New Device From Server",
-        "timezone": "America/Chicago",
-        "last_saw_api": "2017-08-30T20:42:35.854Z"
-      }
-    }),
-    post: () => mockPost,
-  }
+  get: () => Promise.resolve({
+    data: {
+      "id": 6,
+      "name": "New Device From Server",
+      "timezone": "America/Chicago",
+      "last_saw_api": "2017-08-30T20:42:35.854Z"
+    }
+  }),
+  post: () => mockPost,
 }));
 
 import { refresh, initSaveGetId } from "../crud";

frontend/api/__tests__/destroy_tests.ts

@@ -15,9 +15,7 @@ jest.mock("../maybe_start_tracking", () => ({
 
 let mockDelete: Promise<{} | void> = Promise.resolve({});
 jest.mock("axios", () => ({
-  default: {
-    delete: jest.fn(() => mockDelete)
-  }
+  delete: jest.fn(() => mockDelete)
 }));
 
 import { destroy, destroyAll } from "../crud";

frontend/auth/__tests__/actions_test.ts

@@ -1,12 +1,10 @@
 jest.mock("axios", () => ({
-  default: {
-    interceptors: {
-      response: { use: jest.fn() },
-      request: { use: jest.fn() }
-    },
-    post: jest.fn(() => { return Promise.resolve({ data: { foo: "bar" } }); }),
-    get: jest.fn(() => { return Promise.resolve({ data: { foo: "bar" } }); }),
-  }
+  interceptors: {
+    response: { use: jest.fn() },
+    request: { use: jest.fn() }
+  },
+  post: jest.fn(() => { return Promise.resolve({ data: { foo: "bar" } }); }),
+  get: jest.fn(() => { return Promise.resolve({ data: { foo: "bar" } }); }),
 }));
 
 jest.mock("../../api/api", () => ({

frontend/config/__tests__/actions_test.ts

@@ -7,13 +7,11 @@ const mockState = {
 };
 
 jest.mock("axios", () => ({
-  default: {
-    interceptors: {
-      response: { use: jest.fn() },
-      request: { use: jest.fn() }
-    },
-    get() { return Promise.resolve({ data: mockState }); }
-  }
+  interceptors: {
+    response: { use: jest.fn() },
+    request: { use: jest.fn() }
+  },
+  get() { return Promise.resolve({ data: mockState }); }
 }));
 
 jest.mock("../../session", () => ({

frontend/devices/__tests__/actions_test.ts

@@ -26,9 +26,7 @@ jest.mock("../../device", () => ({
 
 let mockGetRelease: Promise<{}> = Promise.resolve({});
 jest.mock("axios", () => ({
-  default: {
-    get: jest.fn(() => { return mockGetRelease; })
-  }
+  get: jest.fn(() => { return mockGetRelease; })
 }));
 
 import * as actions from "../actions";

frontend/devices/components/__tests__/farmbot_os_settings_test.tsx

@@ -1,8 +1,6 @@
 let mockReleaseNoteData = {};
 jest.mock("axios", () => ({
-  default: {
-    get: jest.fn(() => { return Promise.resolve(mockReleaseNoteData); })
-  }
+  get: jest.fn(() => { return Promise.resolve(mockReleaseNoteData); })
 }));
 
 import * as React from "react";

frontend/devices/transfer_ownership/__tests__/create_transfer_cert_failure_test.ts

@@ -4,11 +4,9 @@ jest.mock("../../../device", () => ({ getDevice: () => (mockDevice) }));
 
 jest.mock("axios", () => {
   return {
-    default: {
-      post: jest.fn(() => {
-        return Promise.reject("NOPE");
-      })
-    }
+    post: jest.fn(() => {
+      return Promise.reject("NOPE");
+    })
   };
 });
 

frontend/devices/transfer_ownership/__tests__/create_transfer_cert_test.ts

@@ -7,7 +7,7 @@ jest.mock("../../../device", () => ({
 }));
 
 jest.mock("axios", () => {
-  return { default: { post: jest.fn(() => ({ data: "FAKE CERT" })) } };
+  return { post: jest.fn(() => ({ data: "FAKE CERT" })) };
 });
 
 import { createTransferCert } from "../create_transfer_cert";

frontend/devices/transfer_ownership/__tests__/transfer_ownership_test.ts

@@ -7,7 +7,7 @@ jest.mock("../../../device", () => ({
 }));
 
 jest.mock("axios", () => {
-  return { default: { post: jest.fn(() => ({ data: "FAKE CERT" })) } };
+  return { post: jest.fn(() => ({ data: "FAKE CERT" })) };
 });
 
 import { transferOwnership } from "../transfer_ownership";

frontend/farm_designer/__tests__/util_test.ts

@@ -1,7 +1,5 @@
 let mockPromise: Promise<{} | void> = Promise.resolve();
-jest.mock("axios", () => ({
-  default: { get: () => mockPromise }
-}));
+jest.mock("axios", () => ({ get: () => mockPromise }));
 
 import { executableType, OFSearch } from "../util";
 import { Actions } from "../../constants";

frontend/farm_designer/saved_gardens/__tests__/actions_test.ts

@@ -1,8 +1,6 @@
 jest.mock("axios", () => ({
-  default: {
-    post: jest.fn(() => Promise.resolve()),
-    patch: jest.fn(() => Promise.resolve()),
-  }
+  post: jest.fn(() => Promise.resolve()),
+  patch: jest.fn(() => Promise.resolve()),
 }));
 
 jest.mock("../../../history", () => ({ history: { push: jest.fn() } }));

frontend/farmware/__tests__/actions_test.ts

@@ -1,15 +1,13 @@
 jest.mock("axios", () => ({
-  default: {
-    get: jest.fn(() => {
-      return Promise.resolve({
-        data: [
-          { manifest: "url", name: "farmware0" },
-          { manifest: "url", name: "farmware1" }
-        ]
-      });
-    }),
-    post: jest.fn(() => Promise.resolve()),
-  }
+  get: jest.fn(() => {
+    return Promise.resolve({
+      data: [
+        { manifest: "url", name: "farmware0" },
+        { manifest: "url", name: "farmware1" }
+      ]
+    });
+  }),
+  post: jest.fn(() => Promise.resolve()),
 }));
 
 import { getFirstPartyFarmwareList, retryFetchPackageName } from "../actions";

frontend/farmware/weed_detector/__tests__/actions_tests.ts

@@ -11,10 +11,8 @@ jest.mock("../../../device", () => {
 let mockData = [{ id: 1 }, { id: 2 }, { id: 3 }];
 let mockDelete = Promise.resolve();
 jest.mock("axios", () => ({
-  default: {
-    post: jest.fn(() => Promise.resolve({ data: mockData })),
-    delete: jest.fn(() => mockDelete),
-  }
+  post: jest.fn(() => Promise.resolve({ data: mockData })),
+  delete: jest.fn(() => mockDelete),
 }));
 
 const mockInc = jest.fn();

frontend/front_page/__tests__/front_page_test.tsx

@@ -1,8 +1,7 @@
 let mockAxiosResponse = Promise.resolve({ data: "" });
+
 jest.mock("axios", () => ({
-  default: {
-    post: jest.fn(() => mockAxiosResponse)
-  }
+  post: jest.fn(() => mockAxiosResponse)
 }));
 
 jest.mock("../../session", () => ({
@@ -29,7 +28,7 @@ jest.mock("../../api", () => ({
 import * as React from "react";
 import { mount, shallow } from "enzyme";
 import { FrontPage, setField, PartialFormEvent } from "../front_page";
-import axios from "axios";
+import * as axios from "axios";
 import { API } from "../../api";
 import { Session } from "../../session";
 import { success, error } from "farmbot-toastr";
@@ -62,7 +61,7 @@ describe("<FrontPage />", () => {
     el.setState({ email: "foo@bar.io", loginPassword: "password" });
     await el.instance().submitLogin(fakeEvent as FormEvent);
     expect(API.setBaseUrl).toHaveBeenCalled();
-    expect(axios.post).toHaveBeenCalledWith(
+    expect(axios.default.post).toHaveBeenCalledWith(
       "://localhost:3000/api/tokens/",
       { user: { email: "foo@bar.io", password: "password" } });
     expect(Session.replaceToken).toHaveBeenCalledWith("new data");
@@ -74,7 +73,7 @@ describe("<FrontPage />", () => {
     el.setState({ email: "foo@bar.io", loginPassword: "password" });
     await el.instance().submitLogin(fakeEvent as FormEvent);
     expect(API.setBaseUrl).toHaveBeenCalled();
-    expect(axios.post).toHaveBeenCalledWith(
+    expect(axios.default.post).toHaveBeenCalledWith(
       "://localhost:3000/api/tokens/",
       { user: { email: "foo@bar.io", password: "password" } });
     expect(Session.replaceToken).not.toHaveBeenCalled();
@@ -89,7 +88,7 @@ describe("<FrontPage />", () => {
     el.setState({ email: "foo@bar.io", loginPassword: "password" });
     await el.instance().submitLogin(fakeEvent as FormEvent);
     expect(API.setBaseUrl).toHaveBeenCalled();
-    expect(axios.post).toHaveBeenCalledWith(
+    expect(axios.default.post).toHaveBeenCalledWith(
       "://localhost:3000/api/tokens/",
       { user: { email: "foo@bar.io", password: "password" } });
     await expect(Session.replaceToken).not.toHaveBeenCalled();
@@ -107,7 +106,7 @@ describe("<FrontPage />", () => {
       agreeToTerms: true
     });
     await el.instance().submitRegistration(fakeEvent as FormEvent);
-    expect(axios.post).toHaveBeenCalledWith("usersPath", {
+    expect(axios.default.post).toHaveBeenCalledWith("usersPath", {
       user: {
         agree_to_terms: true, email: "foo@bar.io", name: "Foo Bar",
         password: "password", password_confirmation: "password"
@@ -129,7 +128,7 @@ describe("<FrontPage />", () => {
       agreeToTerms: true
     });
     await el.instance().submitRegistration(fakeEvent as FormEvent);
-    await expect(axios.post).toHaveBeenCalledWith("usersPath", {
+    await expect(axios.default.post).toHaveBeenCalledWith("usersPath", {
       user: {
         agree_to_terms: true, email: "foo@bar.io", name: "Foo Bar",
         password: "password", password_confirmation: "password"
@@ -142,11 +141,12 @@ describe("<FrontPage />", () => {
 
   it("submits forgot password: success", async () => {
     mockAxiosResponse = Promise.resolve({ data: "" });
+    debugger;
     const el = mount<FrontPage>(<FrontPage />);
     el.setState({ email: "foo@bar.io", activePanel: "forgotPassword" });
     await el.instance().submitForgotPassword(
       fakeEvent as React.FormEvent<HTMLFormElement>);
-    await expect(axios.post).toHaveBeenCalledWith("resetPath",
+    await expect(axios.default.post).toHaveBeenCalledWith("resetPath",
       { email: "foo@bar.io" });
     await expect(success).toHaveBeenCalledWith(
       "Email has been sent.", "Forgot Password");
@@ -159,7 +159,7 @@ describe("<FrontPage />", () => {
     el.setState({ email: "foo@bar.io", activePanel: "forgotPassword" });
     await el.instance().submitForgotPassword(
       fakeEvent as React.FormEvent<HTMLFormElement>);
-    await expect(axios.post).toHaveBeenCalledWith("resetPath",
+    await expect(axios.default.post).toHaveBeenCalledWith("resetPath",
       { email: "foo@bar.io" });
     await expect(error).toHaveBeenCalledWith(
       expect.stringContaining("failure"));
@@ -172,7 +172,7 @@ describe("<FrontPage />", () => {
     el.setState({ email: "foo@bar.io", activePanel: "forgotPassword" });
     await el.instance().submitForgotPassword(
       fakeEvent as React.FormEvent<HTMLFormElement>);
-    await expect(axios.post).toHaveBeenCalledWith("resetPath",
+    await expect(axios.default.post).toHaveBeenCalledWith("resetPath",
       { email: "foo@bar.io" });
     await expect(error).toHaveBeenCalledWith(expect.stringContaining(
       "not associated with an account"));

frontend/front_page/__tests__/resend_verification_failure_test.tsx

@@ -1,9 +1,7 @@
 jest.mock("axios", () => ({
-  default: {
-    post: () => Promise.reject({
-      err: "hi"
-    })
-  }
+  post: () => Promise.reject({
+    err: "hi"
+  })
 }));
 
 import { mount } from "enzyme";

frontend/front_page/__tests__/resend_verification_ok_test.tsx

@@ -1,9 +1,7 @@
 jest.mock("axios", () => ({
-  default: {
-    post: () => Promise.resolve({
-      data: "whatever"
-    })
-  }
+  post: () => Promise.resolve({
+    data: "whatever"
+  })
 }));
 
 import { mount } from "enzyme";

frontend/open_farm/__tests__/index_test.tsx

@@ -1,20 +1,18 @@
 
 jest.mock("axios", function () {
   return {
-    default: {
-      get: function () {
-        return Promise.resolve({
+    get: function () {
+      return Promise.resolve({
+        data: {
+          id: 0,
           data: {
-            id: 0,
-            data: {
-              attributes: {
-                svg_icon: "<svg>Wow</svg>",
-                slug: "lettuce"
-              }
+            attributes: {
+              svg_icon: "<svg>Wow</svg>",
+              slug: "lettuce"
             }
           }
-        });
-      }
+        }
+      });
     }
   };
 });

frontend/redux/__tests__/refresh_logs_tests.ts

@@ -1,7 +1,7 @@
 const mockGet = jest.fn(() => {
   return Promise.resolve({ data: [mockLog.body] });
 });
-jest.mock("axios", () => ({ default: { get: mockGet } }));
+jest.mock("axios", () => ({ get: mockGet }));
 import { refreshLogs } from "../refresh_logs";
 import axios from "axios";
 import { API } from "../../api";

frontend/tos_update/__tests__/component_test.tsx

@@ -6,13 +6,11 @@ jest.mock("../../i18n", () => {
 
 jest.mock("axios", () => {
   return {
-    default: {
-      post: jest.fn(() => {
-        return Promise.resolve({
-          data: { token: { unencoded: {}, encoded: "========" } }
-        });
-      })
-    }
+    post: jest.fn(() => {
+      return Promise.resolve({
+        data: { token: { unencoded: {}, encoded: "========" } }
+      });
+    })
   };
 });