wip
This commit is contained in:
Andrew Miner
@@ -1,24 +1,24 @@
|
||||
###
|
||||
# Crafting Guide - crafting_plan.test.coffee
|
||||
#
|
||||
# Copyright (c) 2014 by Redwood Labs
|
||||
# All rights reserved.
|
||||
Crafting Guide - crafting_plan.test.coffee
|
||||
|
||||
Copyright (c) 2014 by Redwood Labs
|
||||
All rights reserved.
|
||||
###
|
||||
|
||||
ModPack = require '../src/scripts/models/mod_pack'
|
||||
CraftingPlan = require '../src/scripts/models/crafting_plan'
|
||||
ModPack = require '../src/scripts/models/mod_pack'
|
||||
CraftingPlan = require '../src/scripts/models/crafting_plan'
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
catalog = plan = null
|
||||
modPack = plan = null
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
describe 'CraftingPlan', ->
|
||||
|
||||
beforeEach ->
|
||||
catalog = new ModPack
|
||||
catalog.loadBookData {
|
||||
modPack = new ModPack
|
||||
modPack.loadModVersionData {
|
||||
version: 1
|
||||
mod_name: 'Minecraft'
|
||||
mod_version: '1.7.10'
|
||||
@@ -31,8 +31,10 @@ describe 'CraftingPlan', ->
|
||||
{ input:[[2, 'Iron Ingot'], 'Stick'], tools:'Crafting Table', output:'Iron Sword' }
|
||||
]
|
||||
}
|
||||
logger.debug "modPack: #{modPack}"
|
||||
logger.debug "modVersion: #{modPack.modVersions[0]}"
|
||||
|
||||
plan = new CraftingPlan catalog
|
||||
plan = new CraftingPlan modPack
|
||||
|
||||
describe 'craft', ->
|
||||
|
||||
@@ -40,40 +42,40 @@ describe 'CraftingPlan', ->
|
||||
|
||||
it 'can craft a single step recipe', ->
|
||||
plan.craft 'Oak Plank'
|
||||
plan.need.toList().should.eql ['Oak Log']
|
||||
plan.result.toList().should.eql [[4, 'Oak Plank']]
|
||||
plan.need.toList().should.eql ['oak_log']
|
||||
plan.result.toList().should.eql [[4, 'oak_plank']]
|
||||
|
||||
it 'can craft a multi-step recipe', ->
|
||||
plan.craft 'Crafting Table'
|
||||
plan.need.toList().should.eql ['Oak Log']
|
||||
plan.result.toList().should.eql ['Crafting Table']
|
||||
plan.need.toList().should.eql ['oak_log']
|
||||
plan.result.toList().should.eql ['crafting_table']
|
||||
|
||||
it 'can craft a multi-step recipe using tools', ->
|
||||
plan.craft 'Furnace'
|
||||
plan.need.toList().should.eql [[8, 'Cobblestone']]
|
||||
plan.result.toList().should.eql ['Furnace']
|
||||
plan.need.toList().should.eql [[8, 'cobblestone']]
|
||||
plan.result.toList().should.eql ['furnace']
|
||||
|
||||
it 'can craft a multi-step recipe re-using tools', ->
|
||||
plan.craft 'Iron Sword'
|
||||
plan.need.toList().should.eql [[2, 'Iron Ore'], 'Oak Log', [2, '{furnace fuel}']]
|
||||
plan.result.toList().should.eql ['Iron Sword', [2, 'Oak Plank'], [3, 'Stick']]
|
||||
plan.need.toList().should.eql [[2, 'furnace_fuel'], [2, 'iron_ore'], 'oak_log']
|
||||
plan.result.toList().should.eql ['iron_sword', [2, 'oak_plank'], [3, 'stick']]
|
||||
|
||||
describe 'with building tools', ->
|
||||
|
||||
it 'can craft a multi-step recipe using tools', ->
|
||||
plan.includingTools = true
|
||||
plan.craft 'Furnace'
|
||||
plan.need.toList().should.eql [[8, 'Cobblestone'], 'Oak Log']
|
||||
plan.result.toList().should.eql ['Crafting Table', 'Furnace']
|
||||
plan.need.toList().should.eql [[8, 'cobblestone'], 'oak_log']
|
||||
plan.result.toList().should.eql ['crafting_table', 'furnace']
|
||||
|
||||
it 'can craft a multi-step recipe re-using tools', ->
|
||||
plan.includingTools = true
|
||||
plan.craft 'Iron Sword'
|
||||
plan.need.toList().should.eql [
|
||||
[8, 'Cobblestone'], [2, 'Iron Ore'], [2, 'Oak Log'], [2, '{furnace fuel}'],
|
||||
[8, 'cobblestone'], [2, 'furnace_fuel'], [2, 'iron_ore'], [2, 'oak_log']
|
||||
]
|
||||
plan.result.toList().should.eql [
|
||||
'Crafting Table', 'Furnace', 'Iron Sword', [2, 'Oak Plank'], [3, 'Stick']
|
||||
'crafting_table', 'furnace', 'iron_sword', [2, 'oak_plank'], [3, 'stick']
|
||||
]
|
||||
|
||||
describe 'using existing inventory', ->
|
||||
|
||||
+29
-29
@@ -20,30 +20,30 @@ describe 'Inventory', ->
|
||||
|
||||
beforeEach ->
|
||||
inventory = new Inventory
|
||||
inventory.add 'wool', 4
|
||||
inventory.add 'string', 20
|
||||
inventory.add 'boat'
|
||||
inventory.add new Item(name:'Wool'), 4
|
||||
inventory.add new Item(name:'String'), 20
|
||||
inventory.add new Item(name:'Boat')
|
||||
|
||||
describe 'add', ->
|
||||
|
||||
it 'can add to an empty inventory', ->
|
||||
inventory.add 'iron ingot', 4
|
||||
item = inventory._items['iron ingot']
|
||||
item.constructor.name.should.equal 'Item'
|
||||
item.name.should.equal 'iron ingot'
|
||||
item.quantity.should.equal 4
|
||||
inventory.add new Item(name:'Iron Ingot'), 4
|
||||
stack = inventory._stacks['iron_ingot']
|
||||
stack.constructor.name.should.equal 'Stack'
|
||||
stack.name.should.equal 'Iron Ingot'
|
||||
stack.quantity.should.equal 4
|
||||
|
||||
it 'can augment quantity of existing items', ->
|
||||
inventory.add 'wool', 2
|
||||
inventory.add new Item(name:'Wool'), 2
|
||||
inventory.toList().should.eql ['boat', [20, 'string'], [6, 'wool']]
|
||||
|
||||
it 'can add zero quantity', ->
|
||||
inventory.add 'wool', 0
|
||||
inventory.add new Item(name:'Wool'), 0
|
||||
inventory.toList().should.eql ['boat', [20, 'string'], [4, 'wool']]
|
||||
|
||||
it 'emits the proper events', ->
|
||||
events = new EventRecorder inventory
|
||||
inventory.add 'iron ingot', 10
|
||||
inventory.add new Item(name:'Iron Ingot'), 10
|
||||
events.names.should.eql [Event.add, Event.change]
|
||||
|
||||
describe 'addInventory', ->
|
||||
@@ -51,11 +51,11 @@ describe 'Inventory', ->
|
||||
it 'can add to an empty inventory', ->
|
||||
newInventory = new Inventory
|
||||
newInventory.addInventory inventory
|
||||
newInventory._names.should.eql ['boat', 'string', 'wool']
|
||||
newInventory._slugs.should.eql ['boat', 'string', 'wool']
|
||||
|
||||
it 'can add a mix of new and existing items', ->
|
||||
newInventory = new Inventory
|
||||
newInventory.add 'string', 2
|
||||
newInventory.add new Item(name:'String'), 2
|
||||
newInventory.addInventory inventory
|
||||
newInventory.toList().should.eql ['boat', [22, 'string'], [4, 'wool']]
|
||||
|
||||
@@ -64,12 +64,12 @@ describe 'Inventory', ->
|
||||
it 'creates an empty inventory from an empty inventory', ->
|
||||
a = new Inventory
|
||||
b = a.clone()
|
||||
b._names.should.eql []
|
||||
b._slugs.should.eql []
|
||||
|
||||
it 'faithfully copies an existing inventory', ->
|
||||
copy = inventory.clone()
|
||||
copy._names.should.eql ['boat', 'string', 'wool']
|
||||
(item.quantity for name, item of copy._items).should.eql [1, 20, 4]
|
||||
logger.debug "copy.toList(): #{copy.toList()}"
|
||||
copy.toList().should.eql ['boat', [20, 'string'], [4, 'wool']]
|
||||
|
||||
describe 'each', ->
|
||||
|
||||
@@ -81,17 +81,17 @@ describe 'Inventory', ->
|
||||
|
||||
it 'works when items have only been added', ->
|
||||
result = []
|
||||
inventory.each (item)-> result.push item.name
|
||||
result.should.eql ['boat', 'string', 'wool']
|
||||
inventory.each (stack)-> result.push stack.name
|
||||
result.should.eql ['Boat', 'String', 'Wool']
|
||||
|
||||
it 'works when items have been augmented', ->
|
||||
inventory.add 'iron ingot'
|
||||
inventory.add 'boat'
|
||||
inventory.add 'wool', 2
|
||||
inventory.add new Item name:'Iron Ingot'
|
||||
inventory.add new Item name:'Boat'
|
||||
inventory.add new Item(name:'Wool'), 2
|
||||
|
||||
result = []
|
||||
inventory.each (item)-> result.push item.name
|
||||
result.should.eql ['boat', 'iron ingot', 'string', 'wool']
|
||||
inventory.each (stack)-> result.push stack.name
|
||||
result.should.eql ['Boat', 'Iron Ingot', 'String', 'Wool']
|
||||
|
||||
describe 'hasAtLeast', ->
|
||||
|
||||
@@ -101,7 +101,7 @@ describe 'Inventory', ->
|
||||
|
||||
it 'always returns true for zero quantity', ->
|
||||
inventory.hasAtLeast('chicken', 0).should.be.true
|
||||
inventory.hasAtLeast('wool', 0).should.be.true
|
||||
inventory.hasAtLeast('Wool', 0).should.be.true
|
||||
|
||||
it 'works for a quantity above 1', ->
|
||||
inventory.hasAtLeast('wool', 3).should.be.true
|
||||
@@ -116,9 +116,9 @@ describe 'Inventory', ->
|
||||
expect(result).to.be.null
|
||||
|
||||
it 'completely removes the last item', ->
|
||||
result = inventory.pop()
|
||||
result.name.should.equal 'wool'
|
||||
result.quantity.should.equal 4
|
||||
stack = inventory.pop()
|
||||
stack.name.should.equal 'Wool'
|
||||
stack.quantity.should.equal 4
|
||||
inventory.toList().should.eql ['boat', [20, 'string']]
|
||||
|
||||
it 'triggers the right events', ->
|
||||
@@ -138,11 +138,11 @@ describe 'Inventory', ->
|
||||
|
||||
it 'removes a single item by default', ->
|
||||
inventory.remove 'wool'
|
||||
inventory._items.wool.quantity.should.equal 3
|
||||
inventory._stacks.wool.quantity.should.equal 3
|
||||
|
||||
it 'removes a quantity above 1', ->
|
||||
inventory.remove 'wool', 3
|
||||
inventory._items.wool.quantity.should.equal 1
|
||||
inventory._stacks.wool.quantity.should.equal 1
|
||||
|
||||
it 'emits the proper events', ->
|
||||
events = new EventRecorder inventory
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
|
||||
Inventory = require '../src/scripts/models/inventory'
|
||||
InventoryParser = require '../src/scripts/models/inventory_parser'
|
||||
Item = require '../src/scripts/models/item'
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
@@ -20,22 +21,22 @@ describe 'InventoryParser', ->
|
||||
|
||||
it 'returns an empty Inventory for an empty string', ->
|
||||
result = parser.parse ''
|
||||
result._names.length.should.equal 0
|
||||
result.toList().should.eql []
|
||||
|
||||
it 'can parse a single item without quantity', ->
|
||||
result = parser.parse 'wool'
|
||||
result._items.wool.quantity.should.equal 1
|
||||
result = parser.parse 'Wool'
|
||||
result.toList().should.eql ['wool']
|
||||
|
||||
it 'can parse a single item with quantity', ->
|
||||
result = parser.parse '4 wool'
|
||||
result._items.wool.quantity.should.equal 4
|
||||
result.toList().should.eql [[4, 'wool']]
|
||||
|
||||
it 'can parse multiple mixed-type items', ->
|
||||
result = parser.parse '4 wool\n10 string\nboat\n\n'
|
||||
result = parser.parse '4 Wool\n10 String\nBoat\n\n'
|
||||
result.toList().should.eql ['boat', [10, 'string'], [4, 'wool']]
|
||||
|
||||
it 're-uses the given inventory object', ->
|
||||
inventory = new Inventory
|
||||
inventory.add 'string', 8
|
||||
result = parser.parse '4 wool', inventory
|
||||
inventory.add new Item(name:'String'), 8
|
||||
result = parser.parse '4 Wool', inventory
|
||||
result.toList().should.eql [[8, 'string'], [4, 'wool']]
|
||||
|
||||
@@ -0,0 +1,115 @@
|
||||
###
|
||||
Crafting Guide - mod_pack.test.coffee
|
||||
|
||||
Copyright (c) 2014 by Redwood Labs
|
||||
All rights reserved.
|
||||
###
|
||||
|
||||
Item = require '../src/scripts/models/item'
|
||||
ModPack = require '../src/scripts/models/mod_pack'
|
||||
ModVersion = require '../src/scripts/models/mod_version'
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
buildcraft = industrialCraft = minecraft = modPack = null
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
describe 'ModPack', ->
|
||||
|
||||
beforeEach ->
|
||||
minecraft = new ModVersion modName:'Minecraft', modVersion:'1.7.10'
|
||||
minecraft.addItem new Item name:'Wool'
|
||||
minecraft.addItem new Item name:'Bed', recipes:['']
|
||||
|
||||
buildcraft = new ModVersion modName:'Buildcraft', modVersion:'4.0'
|
||||
buildcraft.addItem new Item name:'Stone Gear', recipes:['']
|
||||
buildcraft.addItem new Item name:'Bed', recipes:['']
|
||||
|
||||
industrialCraft = new ModVersion modName:'Industrial Craft', modVersion:'2.0'
|
||||
industrialCraft.addItem new Item name:'Resin'
|
||||
industrialCraft.addItem new Item name:'Rubber', recipes:['']
|
||||
|
||||
modPack = new ModPack modVersions:[minecraft, buildcraft, industrialCraft]
|
||||
|
||||
describe 'enableModsForItem', ->
|
||||
|
||||
it 'it ignores already-enabled mod versions', ->
|
||||
buildcraft.enabled = true
|
||||
modPack.enableModsForItem 'Stone Gear'
|
||||
|
||||
minecraft.enabled.should.be.true
|
||||
buildcraft.enabled.should.be.true
|
||||
industrialCraft.enabled.should.be.false
|
||||
|
||||
it 'it ignores mod versions not containing the item', ->
|
||||
modPack.enableModsForItem 'Stone Gear'
|
||||
|
||||
minecraft.enabled.should.be.true
|
||||
buildcraft.enabled.should.be.true
|
||||
industrialCraft.enabled.should.be.false
|
||||
|
||||
it 'enables disabled mod versions with the item', ->
|
||||
modPack.enableModsForItem 'Rubber'
|
||||
|
||||
minecraft.enabled.should.be.true
|
||||
buildcraft.enabled.should.be.false
|
||||
industrialCraft.enabled.should.be.true
|
||||
|
||||
describe 'findItemByName', ->
|
||||
|
||||
it 'finds the requested item', ->
|
||||
item = modPack.findItemByName 'Bed'
|
||||
item.name.should.equal 'Bed'
|
||||
|
||||
it 'ignores disabled mod versions', ->
|
||||
item = modPack.findItemByName 'Stone Gear'
|
||||
expect(item).to.be.null
|
||||
|
||||
it "doesn't ignore mod versions when include disabled is requested", ->
|
||||
item = modPack.findItemByName 'Stone Gear', includeDisabled:true
|
||||
item.name.should.equal 'Stone Gear'
|
||||
|
||||
describe 'gatherRecipeNames', ->
|
||||
|
||||
it 'finds all registered item names', ->
|
||||
buildcraft.enabled = true
|
||||
industrialCraft.enabled = true
|
||||
(i.value for i in modPack.gatherRecipeNames()).sort().should.eql ['Bed', 'Rubber', 'Stone Gear']
|
||||
|
||||
it 'ignores duplicate item names', ->
|
||||
buildcraft.enabled = true
|
||||
names = modPack.gatherRecipeNames()
|
||||
bedName = (e for e in names when e.value is 'Bed')[0]
|
||||
bedName.should.eql value:'Bed', label:'Bed (from Minecraft 1.7.10)'
|
||||
|
||||
it 'alphabetizes the item names', ->
|
||||
buildcraft.enabled = true
|
||||
industrialCraft.enabled = true
|
||||
(i.value for i in modPack.gatherRecipeNames()).should.eql ['Bed', 'Rubber', 'Stone Gear']
|
||||
|
||||
it 'ignores non-craftable items', ->
|
||||
(n.value for n in modPack.gatherRecipeNames()).sort().should.eql ['Bed']
|
||||
|
||||
it 'ignores disabled mod versions', ->
|
||||
(n.value for n in modPack.gatherRecipeNames()).should.not.include 'Stone Gear'
|
||||
|
||||
it "doesn't ignore disabled mod versions when include disabled is requested", ->
|
||||
(n.value for n in modPack.gatherRecipeNames(includeDisabled:true)).should.include 'Stone Gear'
|
||||
|
||||
describe 'hasRecipe', ->
|
||||
|
||||
it 'returns true when the item is present and has recipes', ->
|
||||
modPack.hasRecipe('Bed').should.be.true
|
||||
|
||||
it 'returns false when the item is not present', ->
|
||||
modPack.hasRecipe('Iron Sword').should.be.false
|
||||
|
||||
it 'returns false when the item does not have recipes', ->
|
||||
modPack.hasRecipe('Wool').should.be.false
|
||||
|
||||
it 'ignores disabled mod versions', ->
|
||||
modPack.hasRecipe('Stone Gear').should.be.false
|
||||
|
||||
it 'includes disabled mod versions when include disabled is requested', ->
|
||||
modPack.hasRecipe('Stone Gear', includeDisabled:true).should.be.true
|
||||
@@ -0,0 +1,95 @@
|
||||
###
|
||||
Crafting Guide - mod_version.test.coffee
|
||||
|
||||
Copyright (c) 2014 by Redwood Labs
|
||||
All rights reserved.
|
||||
###
|
||||
|
||||
Item = require '../src/scripts/models/item'
|
||||
ModVersion = require '../src/scripts/models/mod_version'
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
modVersion = null
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
describe 'ModVersion', ->
|
||||
|
||||
beforeEach -> modVersion = new ModVersion modName:'Test', modVersion:'0.0'
|
||||
|
||||
describe 'constructor', ->
|
||||
|
||||
it 'requires a mod name', ->
|
||||
expect(-> new ModVersion modVersion:'0.0').to.throw Error, 'modName cannot be empty'
|
||||
|
||||
it 'requires a mod version', ->
|
||||
expect(-> new ModVersion modName:'Test').to.throw Error, 'modVersion cannot be empty'
|
||||
|
||||
it 'supplies default values', ->
|
||||
modVersion.description.should.equal ''
|
||||
modVersion.items.should.eql {}
|
||||
modVersion.enabled.should.be.false
|
||||
|
||||
describe 'addItem', ->
|
||||
|
||||
it 'refuses to add duplicates', ->
|
||||
modVersion.addItem new Item name:'Wool'
|
||||
expect(-> modVersion.addItem new Item name:'Wool').to.throw Error, 'duplicate item for wool'
|
||||
|
||||
it 'adds an item indexes by its slug', ->
|
||||
modVersion.addItem new Item name:'Wool'
|
||||
modVersion.items.wool.name.should.equal 'Wool'
|
||||
|
||||
describe 'compareTo', ->
|
||||
|
||||
it 'lists required mods first', ->
|
||||
minecraft = new ModVersion modName:'Minecraft', modVersion:'1.7.10'
|
||||
modVersion.compareTo(minecraft).should.equal +1
|
||||
minecraft.compareTo(modVersion).should.equal -1
|
||||
|
||||
it 'sorts by name second', ->
|
||||
buildcraft = new ModVersion modName:'Buildcraft', modVersion:'3.0'
|
||||
modVersion.compareTo(buildcraft).should.equal +1
|
||||
buildcraft.compareTo(modVersion).should.equal -1
|
||||
|
||||
describe 'findItemByName', ->
|
||||
|
||||
it 'locates items by slugified name', ->
|
||||
modVersion.addItem new Item name:'Crafting Table'
|
||||
modVersion.findItemByName('Crafting Table').slug.should.equal 'crafting_table'
|
||||
|
||||
describe 'gatherRecipeNames', ->
|
||||
|
||||
it 'skips names already found', ->
|
||||
modVersion.addItem new Item name:'Wool'
|
||||
modVersion.addItem new Item name:'Oak Wood Planks', recipes:['foo']
|
||||
names = modVersion.gatherRecipeNames {wool:true}
|
||||
names.wool.should.be.true
|
||||
names.oak_wood_planks.value.should.equal 'Oak Wood Planks'
|
||||
|
||||
it 'only includes craftable items', ->
|
||||
modVersion.addItem new Item name:'Wool'
|
||||
modVersion.addItem new Item name:'Oak Wood Planks', recipes:['foo']
|
||||
names = modVersion.gatherRecipeNames()
|
||||
_.keys(names).should.eql ['oak_wood_planks']
|
||||
|
||||
it 'computes the proper value and label', ->
|
||||
modVersion.addItem new Item name:'Oak Wood Planks', recipes:['foo']
|
||||
names = modVersion.gatherRecipeNames()
|
||||
names.oak_wood_planks.value.should.equal 'Oak Wood Planks'
|
||||
names.oak_wood_planks.label.should.equal 'Oak Wood Planks (from Test 0.0)'
|
||||
|
||||
describe 'hasRecipe', ->
|
||||
|
||||
it 'returns false for an unknown item', ->
|
||||
modVersion.addItem new Item name:'Oak Wood Planks', recipes:['foo']
|
||||
modVersion.hasRecipe('Pineapple Upside-Down Cake').should.be.false
|
||||
|
||||
it 'returns false for a un-craftable item', ->
|
||||
modVersion.addItem new Item name:'Wool'
|
||||
modVersion.hasRecipe('Wool').should.be.false
|
||||
|
||||
it 'returns true for a craftable item', ->
|
||||
modVersion.addItem new Item name:'Oak Wood Planks', recipes:['foo']
|
||||
modVersion.hasRecipe('Oak Wood Planks').should.be.true
|
||||
@@ -1,11 +1,13 @@
|
||||
###
|
||||
# Crafting Guide - v1.test.coffee
|
||||
#
|
||||
# Copyright (c) 2014 by Redwood Labs
|
||||
# All rights reserved.
|
||||
Crafting Guide - v1.test.coffee
|
||||
|
||||
Copyright (c) 2014 by Redwood Labs
|
||||
All rights reserved.
|
||||
###
|
||||
|
||||
RecipeBookParser = require '../src/scripts/models/mod_version_parser'
|
||||
Item = require '../src/scripts/models/item'
|
||||
ModVersion = require '../src/scripts/models/mod_version'
|
||||
ModVersionParser = require '../src/scripts/models/mod_version_parser'
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
@@ -13,48 +15,91 @@ parser = null
|
||||
|
||||
########################################################################################################################
|
||||
|
||||
describe 'RecipeBookParser', ->
|
||||
describe 'ModVersionParser', ->
|
||||
|
||||
describe "V1", ->
|
||||
|
||||
before -> parser = new RecipeBookParser.V1
|
||||
before -> parser = new ModVersionParser.V1
|
||||
|
||||
describe '_parseItemList', ->
|
||||
|
||||
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
|
||||
|
||||
it 'can parse an empty list', ->
|
||||
parser._parseItemList []
|
||||
_.keys(parser.modVersion.items).should.eql []
|
||||
|
||||
it 'can add new items', ->
|
||||
parser._parseItemList ['Crafting Table', 'Furnace']
|
||||
_.keys(parser.modVersion.items).should.eql ['crafting_table', 'furnace']
|
||||
|
||||
it 'can find existing items', ->
|
||||
parser.modVersion.addItem new Item name:'Furnace'
|
||||
parser._parseItemList ['Crafting Table', 'Furnace']
|
||||
_.keys(parser.modVersion.items).should.eql ['furnace', 'crafting_table']
|
||||
|
||||
describe '_parseModVersion', ->
|
||||
|
||||
it 'requires a mod_name', ->
|
||||
data = version:1, mod_version:'1.0', recipes:[]
|
||||
data = version:1, mod_version:'1.0', items:[]
|
||||
expect(-> parser._parseModVersion data).to.throw Error, 'mod_name is required'
|
||||
|
||||
it 'requires a mod_version', ->
|
||||
data = version:1, mod_name:'Empty', recipes:[]
|
||||
data = version:1, mod_name:'Empty', items:[]
|
||||
expect(-> parser._parseModVersion data).to.throw Error, 'mod_version is required'
|
||||
|
||||
it 'can parse an empty recipe book', ->
|
||||
it 'can parse an empty modVersion', ->
|
||||
data =
|
||||
version: 1
|
||||
mod_name: 'Empty'
|
||||
mod_version: '1.0'
|
||||
recipes: []
|
||||
book = parser._parseModVersion data
|
||||
book.modName.should.equal 'Empty'
|
||||
book.modVersion.should.equal '1.0'
|
||||
modVersion = parser._parseModVersion data
|
||||
modVersion.modName.should.equal 'Empty'
|
||||
modVersion.modVersion.should.equal '1.0'
|
||||
|
||||
it 'can parse a non-empty recipe book', ->
|
||||
it 'can parse a non-empty mod version', ->
|
||||
data =
|
||||
version: 1
|
||||
mod_name: 'Minecraft'
|
||||
mod_version: '1.7.10'
|
||||
recipes: [
|
||||
{ input:'sugar cane', output:'sugar' }
|
||||
{ input:[[3, 'wool'], [3, 'planks']], tools:'crafting table', output:'bed' }
|
||||
{ input:'Sugar Cane', output:'Sugar' }
|
||||
{ input:[[3, 'Wool'], [3, 'Planks']], tools:'Crafting Table', output:'Bed' }
|
||||
]
|
||||
book = parser._parseModVersion data
|
||||
book.modName.should.equal 'Minecraft'
|
||||
book.modVersion.should.equal '1.7.10'
|
||||
(r.name for r in book.recipes).sort().should.eql ['bed', 'sugar']
|
||||
modVersion = parser._parseModVersion data
|
||||
modVersion.modName.should.equal 'Minecraft'
|
||||
modVersion.modVersion.should.equal '1.7.10'
|
||||
slugs = (slug for slug, item of modVersion.items).sort()
|
||||
slugs.should.eql ['bed', 'crafting_table', 'planks', 'sugar', 'sugar_cane', 'wool']
|
||||
|
||||
describe '_parseRawMaterials', ->
|
||||
|
||||
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
|
||||
|
||||
it 'skips the section when missing', ->
|
||||
parser._parseRawMaterials null
|
||||
_.keys(parser.modVersion._items).length.should.equal 0
|
||||
|
||||
it 'skips the section when empty', ->
|
||||
parser._parseRawMaterials []
|
||||
_.keys(parser.modVersion._items).length.should.equal 0
|
||||
|
||||
it 'adds items marked as gatherable', ->
|
||||
parser._parseRawMaterials ['Wool']
|
||||
parser.modVersion.items['wool'].isGatherable.should.be.true
|
||||
|
||||
it 'marks an existing item as gatherable', ->
|
||||
parser.modVersion.addItem new Item name:'Wool'
|
||||
parser.modVersion.items['wool'].isGatherable.should.be.false
|
||||
parser._parseRawMaterials ['Wool']
|
||||
parser.modVersion.items['wool'].isGatherable.should.be.true
|
||||
|
||||
|
||||
describe '_parseRecipe', ->
|
||||
|
||||
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
|
||||
|
||||
it 'requires output to be defined', ->
|
||||
parser._errorLocation = 'boat'
|
||||
expect(-> parser._parseRecipe input:'wool').to.throw Error, 'boat is missing output'
|
||||
@@ -68,58 +113,62 @@ describe 'RecipeBookParser', ->
|
||||
input: [[3, 'planks'], [3, 'wool']]
|
||||
tools: 'crafting table'
|
||||
recipe = parser._parseRecipe data
|
||||
(i.name for i in recipe.output).should.eql ['bed']
|
||||
(i.name for i in recipe.input).sort().should.eql ['planks', 'wool']
|
||||
(i.name for i in recipe.tools).should.eql ['crafting table']
|
||||
(stack.name for stack in recipe.output).should.eql ['bed']
|
||||
(stack.name for stack in recipe.input).sort().should.eql ['planks', 'wool']
|
||||
(item.name for item in recipe.tools).should.eql ['crafting table']
|
||||
|
||||
it 'can parse a recipe without tools', ->
|
||||
recipe = parser._parseRecipe output:'sugar', input:'sugar cane'
|
||||
(i.name for i in recipe.output).should.eql ['sugar']
|
||||
(i.name for i in recipe.input).sort().should.eql ['sugar cane']
|
||||
(i.name for i in recipe.tools).should.eql []
|
||||
(stack.name for stack in recipe.output).should.eql ['sugar']
|
||||
(stack.name for stack in recipe.input).sort().should.eql ['sugar cane']
|
||||
(stack.name for stack in recipe.tools).should.eql []
|
||||
|
||||
describe '_parseItemList', ->
|
||||
describe '_parseStack', ->
|
||||
|
||||
it 'can promote a single item to a list', ->
|
||||
list = parser._parseItemList 'boat'
|
||||
(i.name for i in list).should.eql ['boat']
|
||||
|
||||
it 'can require a list to be non-empty', ->
|
||||
parser._errorLocation = 'boat'
|
||||
options = field:'output', canBeEmpty:false
|
||||
expect(-> parser._parseItemList [], options).to.throw Error, 'output for boat cannot be empty'
|
||||
|
||||
it 'can allow an empty list', ->
|
||||
list = parser._parseItemList [], canBeEmpty:true
|
||||
list.length.should.equal 0
|
||||
|
||||
it 'can parse a non-empty list', ->
|
||||
list = parser._parseItemList [[3, 'plank'], [3, 'wool']]
|
||||
(i.name for i in list).sort().should.eql ['plank', 'wool']
|
||||
|
||||
describe '_parseItem', ->
|
||||
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
|
||||
|
||||
it 'requires the array to have at least one element', ->
|
||||
parser._errorLocation = 'boat'
|
||||
options = index:1, field:'output'
|
||||
expect(-> parser._parseItem([], options)).to.throw Error,
|
||||
expect(-> parser._parseStack([], options)).to.throw Error,
|
||||
"output element 1 for boat must have at least one element"
|
||||
|
||||
it 'can fill in a missing number', ->
|
||||
item = parser._parseItem 'boat'
|
||||
item = parser._parseStack 'boat'
|
||||
item.name.should.equal 'boat'
|
||||
item.quantity.should.equal 1
|
||||
|
||||
item2 = parser._parseItem ['boat']
|
||||
item2 = parser._parseStack ['boat']
|
||||
item2.name.should.equal 'boat'
|
||||
item2.quantity.should.equal 1
|
||||
|
||||
it 'requires the data to start with a number', ->
|
||||
parser._errorLocation = 'boat'
|
||||
options = index:1, field:'output'
|
||||
expect(-> parser._parseItem(['2', 'book'], options)).to.throw Error,
|
||||
expect(-> parser._parseStack(['2', 'wool'], options)).to.throw Error,
|
||||
"output element 1 for boat must start with a number"
|
||||
|
||||
it 'can parse a basic item', ->
|
||||
item = parser._parseItem [2, 'book']
|
||||
item.constructor.name.should.equal 'Item'
|
||||
stack = parser._parseStack [2, 'wool']
|
||||
stack.constructor.name.should.equal 'Stack'
|
||||
|
||||
describe '_parseStackList', ->
|
||||
|
||||
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
|
||||
|
||||
it 'can promote a single item to a list', ->
|
||||
list = parser._parseStackList 'boat'
|
||||
(i.name for i in list).should.eql ['boat']
|
||||
|
||||
it 'can require a list to be non-empty', ->
|
||||
parser._errorLocation = 'boat'
|
||||
options = field:'output', canBeEmpty:false
|
||||
expect(-> parser._parseStackList [], options).to.throw Error, 'output for boat cannot be empty'
|
||||
|
||||
it 'can allow an empty list', ->
|
||||
list = parser._parseStackList [], canBeEmpty:true
|
||||
list.length.should.equal 0
|
||||
|
||||
it 'can parse a non-empty list', ->
|
||||
list = parser._parseStackList [[3, 'plank'], [3, 'wool']]
|
||||
(i.name for i in list).sort().should.eql ['plank', 'wool']
|
||||
|
||||
@@ -20,6 +20,8 @@ global.should = chai.should()
|
||||
Logger = require '../src/scripts/logger'
|
||||
global.logger = new Logger level:Logger.TRACE
|
||||
|
||||
require '../src/scripts/underscore_mixins'
|
||||
|
||||
# Test Registry ########################################################################################################
|
||||
|
||||
mocha.setup 'bdd'
|
||||
@@ -27,6 +29,8 @@ mocha.setup 'bdd'
|
||||
require './crafting_plan.test'
|
||||
require './inventory.test'
|
||||
require './inventory_parser.test'
|
||||
require './mod_pack.test'
|
||||
require './mod_version.test'
|
||||
require './mod_version_parser.test'
|
||||
|
||||
mocha.checkLeaks()
|
||||
|
||||
Reference in New Issue
Block a user