add step tile tests

2017-07-30 15:19:45 -07:00 · 2017-07-30 15:19:45 -07:00 · d3dc95f60c
parent 045b756867
commit d3dc95f60c
11 changed files with 518 additions and 0 deletions
--- a/src/sequences/step_tiles/tests/tile_execute_script_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_execute_script_test.tsx
@ -0,0 +1,41 @@
+import * as React from "react";
+import { TileExecuteScript } from "../tile_execute_script";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { ExecuteScript } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileExecuteScript/>", () => {
+  function bootstrapTest() {
+    const currentStep: ExecuteScript = {
+      kind: "execute_script",
+      args: {
+        label: "farmware-to-execute"
+      }
+    };
+    return {
+      component: mount(<TileExecuteScript
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    expect(inputs.length).toEqual(2);
+    expect(labels.length).toEqual(1);
+    expect(inputs.first().props().placeholder).toEqual("Run Farmware");
+    expect(labels.at(0).text()).toEqual("Package Name");
+    expect(inputs.at(1).props().value).toEqual("farmware-to-execute");
+    expect(inputs.at(1).props().disabled).toBeTruthy();
+    expect(block.find("small").text()).toContain("farmware selection");
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_execute_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_execute_test.tsx
@ -0,0 +1,39 @@
+import * as React from "react";
+import { ExecuteBlock } from "../tile_execute";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { Execute } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<ExecuteBlock/>", () => {
+  function bootstrapTest() {
+    const currentStep: Execute = {
+      kind: "execute",
+      args: {
+        sequence_id: 0
+      }
+    };
+    return {
+      component: mount(<ExecuteBlock
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    expect(inputs.length).toEqual(1);
+    expect(labels.length).toEqual(1);
+    expect(inputs.first().props().placeholder).toEqual("Execute");
+    expect(labels.at(0).text()).toEqual("Sequence");
+    expect(block.text()).toContain("None");
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_find_home_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_find_home_test.tsx
@ -0,0 +1,46 @@
+import * as React from "react";
+import { TileFindHome } from "../tile_find_home";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { FindHome } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileFindHome/>", () => {
+  function bootstrapTest() {
+    const currentStep: FindHome = {
+      kind: "find_home",
+      args: {
+        speed: 100,
+        axis: "all"
+      }
+    };
+    return {
+      component: mount(<TileFindHome
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    expect(inputs.length).toEqual(5);
+    expect(labels.length).toEqual(4);
+    expect(inputs.first().props().placeholder).toEqual("Find Home");
+    expect(labels.at(0).text()).toContain("Find x");
+    expect(inputs.at(1).props().checked).toBeFalsy();
+    expect(labels.at(1).text()).toContain("Find y");
+    expect(inputs.at(2).props().checked).toBeFalsy();
+    expect(labels.at(2).text()).toContain("Find z");
+    expect(inputs.at(3).props().checked).toBeFalsy();
+    expect(labels.at(3).text()).toContain("Find all");
+    expect(inputs.at(4).props().checked).toBeTruthy();
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_if_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_if_test.tsx
@ -0,0 +1,56 @@
+import * as React from "react";
+import { TileIf } from "../tile_if";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { If } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileIf/>", () => {
+  function bootstrapTest() {
+    const currentStep: If = {
+      kind: "_if",
+      args: {
+        lhs: "pin0",
+        op: "is",
+        rhs: 0,
+        _then: { kind: "nothing", args: {} },
+        _else: { kind: "nothing", args: {} }
+      }
+    };
+    return {
+      component: mount(<TileIf
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    let buttons = block.find("button");
+    expect(inputs.length).toEqual(2);
+    expect(labels.length).toEqual(5);
+    expect(buttons.length).toEqual(4);
+    expect(inputs.first().props().placeholder).toEqual("If Statement");
+    expect(block.text()).toContain("IF...");
+    expect(labels.at(0).text()).toEqual("Variable");
+    expect(buttons.at(0).text()).toEqual("Pin 0");
+    expect(labels.at(1).text()).toEqual("Operator");
+    expect(buttons.at(1).text()).toEqual("is");
+    expect(labels.at(2).text()).toEqual("Value");
+    expect(inputs.at(1).props().value).toEqual(0);
+    expect(block.text()).toContain("THEN...");
+    expect(labels.at(3).text()).toEqual("Execute Sequence");
+    expect(buttons.at(2).text()).toEqual("None");
+    expect(block.text()).toContain("ELSE...");
+    expect(labels.at(4).text()).toEqual("Execute Sequence");
+    expect(buttons.at(3).text()).toEqual("None");
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_move_absolute_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_move_absolute_test.tsx
@ -0,0 +1,69 @@
+import * as React from "react";
+import { TileMoveAbsolute } from "../tile_move_absolute";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { MoveAbsolute } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileMoveAbsolute/>", () => {
+  function bootstrapTest() {
+    const currentStep: MoveAbsolute = {
+      kind: "move_absolute",
+      args: {
+        location: {
+          kind: "coordinate",
+          args: {
+            x: 1,
+            y: 2,
+            z: 3
+          }
+        },
+        speed: 100,
+        offset: {
+          kind: "coordinate",
+          args: {
+            x: 4,
+            y: 5,
+            z: 6
+          }
+        }
+      }
+    };
+    return {
+      component: mount(<TileMoveAbsolute
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    let buttons = block.find("button");
+    expect(inputs.length).toEqual(7);
+    expect(labels.length).toEqual(7);
+    expect(buttons.length).toEqual(1);
+    expect(inputs.first().props().placeholder).toEqual("Move Absolute");
+    expect(labels.at(0).text().toLowerCase()).toEqual("import coordinates from");
+    expect(buttons.at(0).text()).toEqual("None");
+    expect(labels.at(1).text().toLowerCase()).toEqual("x (mm)");
+    expect(inputs.at(1).props().value).toEqual("1");
+    expect(labels.at(2).text().toLowerCase()).toEqual("y (mm)");
+    expect(inputs.at(2).props().value).toEqual("2");
+    expect(labels.at(3).text().toLowerCase()).toEqual("z (mm)");
+    expect(inputs.at(3).props().value).toEqual("3");
+    expect(labels.at(4).text().toLowerCase()).toEqual("x-offset");
+    expect(inputs.at(4).props().value).toEqual("4");
+    expect(labels.at(5).text().toLowerCase()).toEqual("y-offset");
+    expect(inputs.at(5).props().value).toEqual("5");
+    expect(labels.at(6).text().toLowerCase()).toEqual("z-offset");
+    expect(inputs.at(6).props().value).toEqual("6");
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_move_relative_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_move_relative_test.tsx
@ -0,0 +1,46 @@
+import * as React from "react";
+import { TileMoveRelative } from "../tile_move_relative";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { MoveRelative } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileMoveRelative/>", () => {
+  function bootstrapTest() {
+    const currentStep: MoveRelative = {
+      kind: "move_relative",
+      args: {
+        x: 1,
+        y: 2,
+        z: 3,
+        speed: 100
+      }
+    };
+    return {
+      component: mount(<TileMoveRelative
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    expect(inputs.length).toEqual(4);
+    expect(labels.length).toEqual(3);
+    expect(inputs.first().props().placeholder).toEqual("Move Relative");
+    expect(labels.at(0).text().toLowerCase()).toEqual("x (mm)");
+    expect(inputs.at(1).props().value).toEqual(1);
+    expect(labels.at(1).text().toLowerCase()).toEqual("y (mm)");
+    expect(inputs.at(2).props().value).toEqual(2);
+    expect(labels.at(2).text().toLowerCase()).toEqual("z (mm)");
+    expect(inputs.at(3).props().value).toEqual(3);
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_read_pin_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_read_pin_test.tsx
@ -0,0 +1,45 @@
+import * as React from "react";
+import { TileReadPin } from "../tile_read_pin";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { ReadPin } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileReadPin/>", () => {
+  function bootstrapTest() {
+    const currentStep: ReadPin = {
+      kind: "read_pin",
+      args: {
+        pin_number: 3,
+        label: "pinlabel",
+        pin_mode: 1
+      }
+    };
+    return {
+      component: mount(<TileReadPin
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    expect(inputs.length).toEqual(4);
+    expect(labels.length).toEqual(3);
+    expect(inputs.first().props().placeholder).toEqual("Read Pin");
+    expect(labels.at(0).text()).toEqual("Pin Number");
+    expect(inputs.at(1).props().value).toEqual(3);
+    expect(labels.at(1).text()).toEqual("Data Label");
+    expect(inputs.at(2).props().value).toEqual("pinlabel");
+    expect(labels.at(2).text()).toEqual("Pin Mode");
+    expect(inputs.at(3).props().value).toEqual(1);
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_send_message_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_send_message_test.tsx
@ -0,0 +1,58 @@
+import * as React from "react";
+import { TileSendMessage } from "../tile_send_message";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { SendMessage } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileSendMessage/>", () => {
+  function bootstrapTest() {
+    const currentStep: SendMessage = {
+      kind: "send_message",
+      args: {
+        message: "send this message",
+        message_type: "info"
+      },
+      body: [{
+        kind: "channel",
+        args: {
+          channel_name: "toast"
+        }
+      }]
+    };
+    return {
+      component: mount(<TileSendMessage
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    let buttons = block.find("button");
+    expect(inputs.length).toEqual(5);
+    expect(labels.length).toEqual(4);
+    expect(buttons.length).toEqual(1);
+    expect(inputs.first().props().placeholder).toEqual("Send Message");
+    expect(labels.at(0).text()).toEqual("Message");
+    expect(inputs.at(1).props().value).toEqual("send this message");
+    expect(buttons.at(0).text()).toEqual("Info");
+    expect(labels.at(1).text()).toEqual("Ticker Notification");
+    expect(inputs.at(2).props().checked).toBeTruthy();
+    expect(inputs.at(2).props().disabled).toBeTruthy();
+    expect(labels.at(2).text()).toEqual("Toast Pop Up");
+    expect(inputs.at(3).props().checked).toBeTruthy();
+    expect(inputs.at(3).props().disabled).toBeFalsy();
+    expect(labels.at(3).text()).toEqual("Email");
+    expect(inputs.at(4).props().checked).toBeFalsy();
+    expect(inputs.at(4).props().disabled).toBeFalsy();
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_take_photo_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_take_photo_test.tsx
@ -0,0 +1,34 @@
+import * as React from "react";
+import { TileTakePhoto } from "../tile_take_photo";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { TakePhoto } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileTakePhoto/>", () => {
+  function bootstrapTest() {
+    const currentStep: TakePhoto = {
+      kind: "take_photo",
+      args: {}
+    };
+    return {
+      component: mount(<TileTakePhoto
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    expect(inputs.length).toEqual(1);
+    expect(inputs.first().props().placeholder).toEqual("Take a Photo");
+    expect(block.text()).toContain("farmware page");
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_wait_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_wait_test.tsx
@ -0,0 +1,39 @@
+import * as React from "react";
+import { TileWait } from "../tile_wait";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { Wait } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileWait/>", () => {
+  function bootstrapTest() {
+    const currentStep: Wait = {
+      kind: "wait",
+      args: {
+        milliseconds: 100
+      }
+    };
+    return {
+      component: mount(<TileWait
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    expect(inputs.length).toEqual(2);
+    expect(labels.length).toEqual(1);
+    expect(inputs.first().props().placeholder).toEqual("Wait");
+    expect(labels.at(0).text()).toEqual("Time in milliseconds");
+    expect(inputs.at(1).props().value).toEqual(100);
+  });
+});
--- a/src/sequences/step_tiles/tests/tile_write_pin_test.tsx
+++ b/src/sequences/step_tiles/tests/tile_write_pin_test.tsx
@ -0,0 +1,45 @@
+import * as React from "react";
+import { TileWritePin } from "../tile_write_pin";
+import { mount } from "enzyme";
+import { fakeSequence } from "../../../__test_support__/fake_state/resources";
+import { WritePin } from "farmbot/dist";
+import { emptyState } from "../../../resources/reducer";
+
+describe("<TileWritePin/>", () => {
+  function bootstrapTest() {
+    const currentStep: WritePin = {
+      kind: "write_pin",
+      args: {
+        pin_number: 3,
+        pin_value: 2,
+        pin_mode: 1
+      }
+    };
+    return {
+      component: mount(<TileWritePin
+        currentSequence={fakeSequence()}
+        currentStep={currentStep}
+        dispatch={jest.fn()}
+        index={0}
+        sequences={[]}
+        tools={[]}
+        slots={[]}
+        resources={emptyState().index} />)
+    };
+  }
+
+  it("renders inputs", () => {
+    let block = bootstrapTest().component;
+    let inputs = block.find("input");
+    let labels = block.find("label");
+    expect(inputs.length).toEqual(4);
+    expect(labels.length).toEqual(3);
+    expect(inputs.first().props().placeholder).toEqual("Write Pin");
+    expect(labels.at(0).text()).toEqual("Pin Number");
+    expect(inputs.at(1).props().value).toEqual(3);
+    expect(labels.at(1).text()).toEqual("Value");
+    expect(inputs.at(2).props().value).toEqual(2);
+    expect(labels.at(2).text()).toEqual("Pin Mode");
+    expect(inputs.at(3).props().value).toEqual(1);
+  });
+});