Merge pull request #31 from streamdevs/5-disco-mode

5 disco mode

Author: SantiMA10

packages/lul/src/services/light/FakeLightService.ts

@@ -4,4 +4,5 @@ export class FakeLightService implements LightService {
   public turnOff = jest.fn();
   public turnOn = jest.fn();
   public changeColor = jest.fn();
+  public disco = jest.fn();
 }

packages/lul/src/services/light/LifxLightService.ts

@@ -9,11 +9,37 @@ interface ChangeColorOptions {
   duration?: number;
 }
 
+interface DiscoOptions {
+  color: string;
+  cycles: number;
+  period: number;
+  initialColor?: string;
+}
+
 export class LifxLightService implements LightService {
   public constructor(
     private driver: HttpDriver = DriverFactory.buildHttpDriver()
   ) {}
 
+  public async disco(light: Light, options: DiscoOptions): Promise<void> {
+    const { color, cycles, period, initialColor } = options;
+
+    await this.driver.post(
+      `https://api.lifx.com/v1/lights/id:${light.id}/effects/breathe`,
+      {
+        payload: {
+          color,
+          cycles,
+          period,
+          ...(initialColor && { from_color: initialColor }),
+        },
+        headers: {
+          Authorization: `Bearer ${getConfiguration().lifx.accessToken}`,
+        },
+      }
+    );
+  }
+
   public async changeColor(
     light: Light,
     options: ChangeColorOptions

packages/lul/src/services/light/LightService.ts

@@ -4,4 +4,13 @@ export interface LightService {
   turnOn(light: Light): Promise<void>;
   turnOff(light: Light): Promise<void>;
   changeColor(light: Light, options: any): Promise<void>;
+  disco(
+    light: Light,
+    options: {
+      color: string;
+      cycles: number;
+      period: number;
+      initialColor?: string;
+    }
+  ): Promise<void>;
 }

packages/lul/src/useCases/rewards/Disco.ts

@@ -0,0 +1,33 @@
+import stc from "string-to-color";
+import { Reward, Light } from "../../entities";
+import { LifxLightService, LightService } from "../../services";
+import { RewardActionUseCase } from "./RewardActionUseCase";
+
+type PerformOptions = {
+  reward: Reward;
+  lights: Light[];
+};
+
+export class Disco implements RewardActionUseCase {
+  public constructor(
+    private lightService: LightService = new LifxLightService()
+  ) {}
+
+  public async perform({ reward, lights }: PerformOptions): Promise<void> {
+    const color = stc(reward.message);
+    const initialColor = stc(reward.date);
+
+    await Promise.all(
+      lights.map((light) =>
+        this.lightService.disco(light, {
+          color,
+          initialColor,
+          cycles: 5,
+          period: 20,
+        })
+      )
+    );
+  }
+}
+
+export default Disco;

packages/lul/tests/services/light/LifxLightService.spec.ts

@@ -137,4 +137,61 @@ describe("LifxLightService", () => {
       ).rejects.toThrow(new Error("Boom!"));
     });
   });
+
+  describe("#disco", () => {
+    it("calls the LIFX API with the color, cycles, period and lights", async () => {
+      const driver = new FakeHttpDriver();
+      const subject = new LifxLightService(driver);
+      const light = LightBuilder.build({ service: "LIFX" });
+
+      await subject.disco(light, { color: "red", cycles: 5, period: 5 });
+
+      expect(driver.post).toHaveBeenCalledWith(
+        `https://api.lifx.com/v1/lights/id:${light.id}/effects/breathe`,
+        {
+          payload: { color: "red", cycles: 5, period: 5 },
+          headers: { Authorization: "Bearer fake-lifx-token" },
+        }
+      );
+    });
+
+    it("calls the LIFX API with the initialColor, color, cycles, period and lights", async () => {
+      const driver = new FakeHttpDriver();
+      const subject = new LifxLightService(driver);
+      const light = LightBuilder.build({ service: "LIFX" });
+
+      await subject.disco(light, {
+        color: "red",
+        cycles: 5,
+        period: 5,
+        initialColor: "blue",
+      });
+
+      expect(driver.post).toHaveBeenCalledWith(
+        `https://api.lifx.com/v1/lights/id:${light.id}/effects/breathe`,
+        {
+          payload: { color: "red", cycles: 5, period: 5, from_color: "blue" },
+          headers: { Authorization: "Bearer fake-lifx-token" },
+        }
+      );
+    });
+
+    it("throws the error if the driver fails", async () => {
+      const driver = new FakeHttpDriver();
+      driver.post.mockImplementation(() => {
+        throw new Error("Boom!");
+      });
+      const light = LightBuilder.build({ service: "LIFX" });
+      const subject = new LifxLightService(driver);
+
+      await expect(
+        subject.disco(light, {
+          color: "red",
+          cycles: 5,
+          period: 5,
+          initialColor: "blue",
+        })
+      ).rejects.toThrow(new Error("Boom!"));
+    });
+  });
 });

packages/lul/tests/useCases/rewards/Disco.spec.ts

@@ -0,0 +1,49 @@
+import stc from "string-to-color";
+import { FakeLightService } from "../../../src";
+import { Disco } from "../../../src/useCases/rewards/Disco";
+import { LightBuilder } from "../../builders/LightBuilder";
+import { RewardBuilder } from "../../builders/RewardBuilder";
+
+jest.mock("string-to-color", () => jest.fn(() => "#fefefe"));
+
+describe("Disco", () => {
+  describe("#perform", () => {
+    it("uses the reward message to generate the color for the disco mode", async () => {
+      const lightService = new FakeLightService();
+      const subject = new Disco(lightService);
+      const reward = RewardBuilder.build();
+      const lights = LightBuilder.buildList(1);
+
+      await subject.perform({ reward, lights });
+
+      expect(stc).toHaveBeenCalledWith(reward.message);
+    });
+
+    it("uses the reward date to generate the initialColor for the disco mode", async () => {
+      const lightService = new FakeLightService();
+      const subject = new Disco(lightService);
+      const reward = RewardBuilder.build();
+      const lights = LightBuilder.buildList(1);
+
+      await subject.perform({ reward, lights });
+
+      expect(stc).toHaveBeenCalledWith(reward.date);
+    });
+
+    it("uses light service to start the disco mode", async () => {
+      const lightService = new FakeLightService();
+      const subject = new Disco(lightService);
+      const reward = RewardBuilder.build();
+      const lights = LightBuilder.buildList(1);
+
+      await subject.perform({ reward, lights });
+
+      expect(lightService.disco).toHaveBeenCalledWith(lights[0], {
+        color: "#fefefe",
+        initialColor: "#fefefe",
+        cycles: 5,
+        period: 20,
+      });
+    });
+  });
+});