@jeremyckahn/farmhand 1.24.0 → 1.24.2

package/src/game-logic/reducers/modifyCow.test.ts

@@ -0,0 +1,33 @@
+import { getCowStub } from '../../test-utils/stubs/cowStub.js'
+import { testState } from '../../test-utils/index.js'
+
+import { modifyCow } from './modifyCow.js'
+
+describe('modifyCow', () => {
+  test('updates the matching cow', () => {
+    const cow1 = getCowStub({ id: 'cow-1', name: 'Bessie' })
+    const cow2 = getCowStub({ id: 'cow-2', name: 'Daisy' })
+    const state = testState({ cowInventory: [cow1, cow2] })
+
+    const { cowInventory } = modifyCow(state, 'cow-2', () => ({
+      name: 'Clover',
+    }))
+
+    expect(cowInventory).toEqual([cow1, { ...cow2, name: 'Clover' }])
+  })
+
+  test('does not mutate the original cowInventory', () => {
+    const cow = getCowStub({ id: 'cow-1' })
+    const state = testState({ cowInventory: [cow] })
+
+    modifyCow(state, 'cow-1', () => ({ name: 'Clover' }))
+
+    expect(state.cowInventory).toEqual([cow])
+  })
+
+  test('no-ops if the cow does not exist', () => {
+    const state = testState({ cowInventory: [getCowStub({ id: 'cow-1' })] })
+
+    expect(modifyCow(state, 'missing', () => ({ name: 'x' }))).toBe(state)
+  })
+})

package/src/game-logic/reducers/modifyCow.ts

@@ -1,4 +1,5 @@
-// TODO: Add tests for this reducer
+import { findCowById } from '../../utils/findCowById.js'
+
 /**
  * @param fn Function that takes a cow and returns the modified cow or undefined.
  */
@@ -7,21 +8,15 @@ export const modifyCow = (
   cowId: string,
   fn: (cow: farmhand.cow) => Partial<farmhand.cow>
 ): farmhand.state => {
-  const cowInventory = [...state.cowInventory]
-
-  // TODO: Use the findCowById util here.
-  const cow = cowInventory.find(({ id }) => id === cowId)
+  const cow = findCowById(state.cowInventory, cowId)
 
   if (!cow) {
     return state
   }
 
+  const cowInventory = [...state.cowInventory]
   const cowIndex = cowInventory.indexOf(cow)
 
-  if (cowIndex === -1) {
-    return state
-  }
-
   cowInventory[cowIndex] = {
     ...cow,
     ...fn(cow),

package/src/game-logic/reducers/purchaseItem.test.ts

@@ -1,4 +1,6 @@
 import { INFINITE_STORAGE_LIMIT } from '../../constants.js'
+import { huggingMachine } from '../../data/items.js'
+import { generateCow } from '../../utils/generateCow.js'
 import { testItem, testState } from '../../test-utils/index.js'
 
 import { purchaseItem } from './purchaseItem.js'
@@ -81,5 +83,132 @@ describe('purchaseItem', () => {
         })
       })
     })
+
+    test('respects an item maximum purchase quantity', () => {
+      const item = testItem({
+        id: 'sample-item-1',
+        getMaxPurchaseQuantity: () => 2,
+      })
+
+      expect(purchaseItem(state, item, 5)).toMatchObject({
+        inventory: [{ id: 'sample-item-1', quantity: 2 }],
+        todaysPurchases: { 'sample-item-1': 2 },
+        money: 8,
+      })
+    })
+
+    test('does not purchase when an item maximum is negative', () => {
+      const item = testItem({
+        id: 'sample-item-1',
+        getMaxPurchaseQuantity: () => -2,
+      })
+
+      expect(purchaseItem(state, item, 1)).toMatchObject({
+        inventory: [],
+        todaysPurchases: {},
+        money: 10,
+      })
+    })
+
+    describe('the item has a maximum purchase quantity', () => {
+      test.each([
+        [1, 10],
+        [2, 20],
+        [3, 30],
+      ])(
+        'limits Hugging Machines to the Cow Pen capacity of %i cows',
+        (purchasedCowPen, cowCapacity) => {
+          state = testState({
+            inventory: [],
+            money: 10_000,
+            purchasedCowPen,
+            valueAdjustments: { [huggingMachine.id]: 1 },
+          })
+
+          expect(huggingMachine.getMaxPurchaseQuantity?.(state)).toEqual(
+            cowCapacity
+          )
+        }
+      )
+
+      test('limits the purchase to the remaining Cow Pen capacity', () => {
+        state = testState({
+          inventory: [{ id: huggingMachine.id, quantity: 9 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 2)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 10 }],
+          todaysPurchases: { [huggingMachine.id]: 1 },
+          money: 9_500,
+          pendingPeerMessages: [
+            { message: 'purchased 1 unit of Hugging Machine.' },
+          ],
+        })
+      })
+
+      test('does not purchase a Hugging Machine when capacity is full', () => {
+        state = testState({
+          inventory: [{ id: huggingMachine.id, quantity: 10 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 10 }],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+
+      test('does not purchase a Hugging Machine when already over capacity', () => {
+        state = testState({
+          inventory: [{ id: huggingMachine.id, quantity: 11 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 11 }],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+
+      test('does not purchase a Hugging Machine when all capacity is in use', () => {
+        state = testState({
+          cowInventory: Array.from({ length: 6 }, () =>
+            generateCow({ isUsingHuggingMachine: true })
+          ),
+          inventory: [{ id: huggingMachine.id, quantity: 4 }],
+          money: 10_000,
+          purchasedCowPen: 1,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [{ id: huggingMachine.id, quantity: 4 }],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+
+      test('does not purchase a Hugging Machine without a Cow Pen', () => {
+        state = testState({
+          money: 10_000,
+          valueAdjustments: { [huggingMachine.id]: 1 },
+        })
+
+        expect(purchaseItem(state, huggingMachine, 1)).toMatchObject({
+          inventory: [],
+          todaysPurchases: {},
+          money: 10_000,
+        })
+      })
+    })
   })
 })

package/src/game-logic/reducers/purchaseItem.ts

@@ -13,7 +13,14 @@ export const purchaseItem = (
   howMany: number = 1
 ): farmhand.state => {
   const { money, todaysPurchases, valueAdjustments } = state
-  const numberOfItemsToAdd = Math.min(howMany, inventorySpaceRemaining(state))
+
+  const getMaxPurchaseQuantity =
+    item.getMaxPurchaseQuantity?.(state) ?? Infinity
+
+  const numberOfItemsToAdd = Math.max(
+    0,
+    Math.min(howMany, inventorySpaceRemaining(state), getMaxPurchaseQuantity)
+  )
 
   if (numberOfItemsToAdd === 0) {
     return state
@@ -28,7 +35,7 @@ export const purchaseItem = (
 
   state = prependPendingPeerMessage(
     state,
-    PURCHASED_ITEM_PEER_NOTIFICATION('', howMany, item)
+    PURCHASED_ITEM_PEER_NOTIFICATION('', numberOfItemsToAdd, item)
   )
 
   return addItemToInventory(

package/src/shell/bootup.test.ts

@@ -55,6 +55,37 @@ describe('bootup', () => {
     })
   })
 
+  test('does not announce already-learned recipes as newly learned when booting from a save file', async () => {
+    const loadedState = saveDataStubFactory({
+      dayCount: 10,
+      learnedRecipes: { bread: true, butter: true },
+    })
+
+    await farmhandStub({
+      localforage: {
+        getItem: () => Promise.resolve(loadedState),
+        setItem: (_key: string, data: unknown) => Promise.resolve(data),
+      },
+    })
+
+    await waitFor(() => {
+      expect(
+        screen.getByText('Day 10', {
+          exact: false,
+          selector: '.day-and-progress-container span',
+        })
+      ).toBeInTheDocument()
+    })
+
+    // Notifications are deferred via setTimeout(0) and flushed after boot, so
+    // give them a moment to (incorrectly) appear.
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    expect(
+      screen.queryByText(/You learned the recipes/)
+    ).not.toBeInTheDocument()
+  })
+
   test(
     'pending notifications for the loaded day are not shown again the next day',
     async () => {

package/src/utils/getItemById.test.ts

@@ -0,0 +1,18 @@
+import { carrot } from '../data/items.js'
+
+import { getItemById } from './getItemById.js'
+
+vitest.mock('../data/maps.js')
+vitest.mock('../data/items.js')
+
+describe('getItemById', () => {
+  test('returns the item for a known id', () => {
+    expect(getItemById('carrot')).toEqual(carrot)
+  })
+
+  test('throws an informative error for an unknown id', () => {
+    expect(() => getItemById('not-a-real-item')).toThrow(
+      'Unknown item id: not-a-real-item'
+    )
+  })
+})

package/src/utils/getItemById.ts

@@ -0,0 +1,14 @@
+import { itemsMap } from '../data/maps.js'
+
+/**
+ * @throws If no item exists for the provided id.
+ */
+export const getItemById = (id: string): farmhand.item => {
+  const item = itemsMap[id as keyof typeof itemsMap]
+
+  if (!item) {
+    throw new Error(`Unknown item id: ${id}`)
+  }
+
+  return item
+}

package/src/utils/getPlotImage.ts

@@ -64,9 +64,7 @@ export const getPlotImage = (
 
     if (getPlotContentType(plotContents) === itemType.WEED) {
       const weedColors = ['yellow', 'orange', 'pink']
-      // TODO: Handle negative coordinates by using Math.abs(x * y) to avoid
-      // negative modulo index.
-      const color = weedColors[(x * y) % weedColors.length]
+      const color = weedColors[Math.abs(x * y) % weedColors.length]
 
       return (itemImages as Record<string, string>)[`weed-${color}`]
     }

package/src/utils/transformStateDataForImport.test.ts

@@ -27,6 +27,15 @@ describe('transformStateDataForImport', () => {
     expect(sanitizedState).toEqual(stateWithoutVersion)
   })
 
+  test('it does not throw if cowBreedingPen and cowInventory are missing', () => {
+    delete state.cowBreedingPen
+    delete state.cowInventory
+
+    const sanitizedState = transformStateDataForImport(state as any)
+
+    expect(sanitizedState.cowBreedingPen).toBeUndefined()
+  })
+
   test('it calculates experience from itemsSold if experience is 0', () => {
     state.experience = 0
     state.itemsSold = {

package/src/utils/transformStateDataForImport.ts

@@ -34,20 +34,17 @@ export const transformStateDataForImport = (
   // cowInventory, but at least one player's game somehow got into that state.
   // This block detects such an invalid state and corrects it.
   {
-    // TODO: Add defensive check safeguards for sanitizedState.cowBreedingPen
-    // and sanitizedState.cowInventory to prevent TypeError crashes during
-    // corrupt/legacy state imports.
-    const { cowId1, cowId2 } =
-      sanitizedState.cowBreedingPen as farmhand.state['cowBreedingPen']
+    const { cowId1, cowId2 } = (sanitizedState.cowBreedingPen ?? {}) as Partial<
+      farmhand.state['cowBreedingPen']
+    >
 
-    const cowPenIdMap = (sanitizedState.cowInventory as farmhand.cow[]).reduce(
-      (acc: Record<string, farmhand.cow>, cow: farmhand.cow) => {
-        acc[cow.id] = cow
+    const cowPenIdMap = (
+      (sanitizedState.cowInventory ?? []) as farmhand.cow[]
+    ).reduce((acc: Record<string, farmhand.cow>, cow: farmhand.cow) => {
+      acc[cow.id] = cow
 
-        return acc
-      },
-      {}
-    )
+      return acc
+    }, {})
 
     const isCowInBreedingPenMissingFromInventory = [cowId1, cowId2].some(
       cowId => {