tataru 0.1.0 → 0.2.0

data/spec/instructions/value_instruction_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::ValueInstruction do
+  it 'set a value' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueInstruction.new('something')
+
+    mem.hash[:temp] = { _key: :somefield }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(somefield: 'something')
+  end
+
+  it 'returns an error if no key' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueInstruction.new('something')
+
+    mem.hash[:temp] = {}
+    instr.memory = mem
+    instr.run
+
+    expect(mem.error).to eq 'No key set'
+  end
+end

data/spec/instructions/value_rom_instruction_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::ValueRomInstruction do
+  it 'returns an error if no key' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueRomInstruction.new('something')
+
+    mem.hash[:rom] = {}
+    mem.hash[:temp] = {}
+    instr.memory = mem
+    instr.run
+
+    expect(mem.error).to eq 'No key set'
+  end
+
+  it 'returns an error if no such thing' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueRomInstruction.new('something')
+
+    mem.hash[:rom] = {}
+    mem.hash[:temp] = { _key: :somefield }
+    instr.memory = mem
+    expect { instr.run }.to raise_error 'Not found'
+  end
+
+  it 'sets a literal' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueRomInstruction.new('something')
+
+    mem.hash[:rom] = {
+      'something' => {
+        type: :literal,
+        value: 'somevalue'
+      }
+    }
+    mem.hash[:temp] = { _key: :somefield }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(somefield: 'somevalue')
+  end
+
+  it 'sets an array' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueRomInstruction.new('something')
+
+    mem.hash[:rom] = {
+      'something' => {
+        type: :array,
+        references: {
+          0 => 'a',
+          1 => 'b'
+        }
+      },
+      'a' => {
+        type: :literal,
+        value: 'meow'
+      },
+      'b' => {
+        type: :literal,
+        value: 'woof'
+      }
+    }
+    mem.hash[:temp] = { _key: :somefield }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(somefield: ['meow', 'woof'])
+  end
+
+  it 'sets a hash' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueRomInstruction.new('something')
+
+    mem.hash[:rom] = {
+      'something' => {
+        type: :hash,
+        references: {
+          'x' => 'aaa',
+          'y' => 'bbbb'
+        }
+      },
+      'aaa' => {
+        type: :literal,
+        value: 100
+      },
+      'bbbb' => {
+        type: :literal,
+        value: 200
+      }
+    }
+    mem.hash[:temp] = { _key: :somefield }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(somefield: {
+      'x' => 100,
+      'y' => 200
+    })
+  end
+
+  it 'sets an output' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueRomInstruction.new('something')
+
+    mem.hash[:outputs] = {
+      'someresource' => {
+        name: 'somename'
+      }
+    }
+
+    mem.hash[:rom] = {
+      'something' => {
+        type: :output,
+        resource: 'someresource',
+        output: :name
+      }
+    }
+    mem.hash[:temp] = { _key: :somefield }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(somefield: 'somename')
+  end
+
+  it 'sets inner values' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueRomInstruction.new('something')
+
+    mem.hash[:rom] = {
+      'something' => {
+        type: :hash,
+        references: {
+          'x' => 'literal',
+          'y' => 'array'
+        }
+      },
+      'literal' => {
+        type: :literal,
+        value: 'something'
+      },
+      'array' => {
+        type: :array,
+        references: {
+          0 => 'value1',
+          1 => 'value2'
+        }
+      },
+      'value1' => {
+        type: :literal,
+        value: 'v1'
+      },
+      'value2' => {
+        type: :literal,
+        value: 'v2'
+      }
+    }
+    mem.hash[:temp] = { _key: :somefield }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(somefield: {
+      'x' => 'something',
+      'y' => ['v1', 'v2']
+    })
+  end
+
+end

data/spec/instructions/value_update_instruction_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::ValueUpdateInstruction do
+  it 'sets temp with update action of resource' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueUpdateInstruction.new('thething')
+
+    mem.hash[:update_action] = {
+      'thething' => :hello
+    }
+
+    mem.hash[:temp] = {}
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(
+      result: :hello
+    )
+  end
+
+  it 'throws if no such resource' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ValueUpdateInstruction.new('thething')
+
+    mem.hash[:update_action] = {}
+
+    mem.hash[:temp] = {}
+
+    instr.memory = mem
+    expect { instr.run }.to raise_error "No value set for 'thething'"
+  end
+end

data/spec/quest_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Quest do
+
+
+
+end

data/spec/representations/array_representation_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Representations::ArrayRepresentation do
+  it 'has no dependencies for empty array' do
+    rep = Tataru::Representations::ArrayRepresentation.new([])
+    expect(rep.dependencies).to eq []
+  end
+
+  it 'has no dependencies for array with only literals' do
+    rep = Tataru::Representations::ArrayRepresentation.new(['hi'])
+    expect(rep.dependencies).to eq []
+  end
+
+  it 'has dependencies for each resource' do
+    rr = Tataru::Representations::ResourceRepresentation.new('file', Tataru::BaseResourceDesc.new, {})
+    rep = Tataru::Representations::ArrayRepresentation.new([rr])
+    expect(rep.dependencies).to eq ['file']
+  end
+
+  it 'has dependencies for every resource' do
+    rr1 = Tataru::Representations::ResourceRepresentation.new('file1', Tataru::BaseResourceDesc.new, {})
+    rr2 = Tataru::Representations::ResourceRepresentation.new('file2', Tataru::BaseResourceDesc.new, {})
+    rep = Tataru::Representations::ArrayRepresentation.new([rr1, rr2, 'awd'])
+
+    expect(rep.dependencies).to eq ['file1', 'file2']
+  end
+end

data/spec/representations/hash_representation_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Representations::HashRepresentation do
+  it 'has no dependencies for empty array' do
+    rep = Tataru::Representations::HashRepresentation.new({})
+    expect(rep.dependencies).to eq []
+  end
+
+  it 'has no dependencies for array with only literals' do
+    rep = Tataru::Representations::HashRepresentation.new({'greeting' => 'hi'})
+    expect(rep.dependencies).to eq []
+  end
+
+  it 'has dependencies for each resource' do
+    rr = Tataru::Representations::ResourceRepresentation.new('file', Tataru::BaseResourceDesc.new, {})
+    rep = Tataru::Representations::HashRepresentation.new(thing: rr)
+    expect(rep.dependencies).to eq ['file']
+  end
+
+  it 'has dependencies for every resource' do
+    rr1 = Tataru::Representations::ResourceRepresentation.new('file1', Tataru::BaseResourceDesc.new, {})
+    rr2 = Tataru::Representations::ResourceRepresentation.new('file2', Tataru::BaseResourceDesc.new, {})
+    rep = Tataru::Representations::HashRepresentation.new(thing1: rr1, thing2: rr2, text: 'hello')
+    
+    expect(rep.dependencies).to eq ['file1', 'file2']
+  end
+end

data/spec/representations/literal_representation_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Representation do
+  it 'has no dependencies' do
+    rep = Tataru::Representations::LiteralRepresentation.new('hello')
+    expect(rep.dependencies).to eq []
+  end
+end

data/spec/representations/output_representation_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Representations::OutputRepresentation do
+  it 'has a dependency on itself' do
+    rr = Tataru::Representations::OutputRepresentation.new('file', 'created_at')
+
+    expect(rr.dependencies).to eq ['file']
+  end
+end

data/spec/representations/resource_representation_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Representations::ResourceRepresentation do
+  it 'has a dependency on itself' do
+    rr = Tataru::Representations::ResourceRepresentation.new('file', Tataru::BaseResourceDesc.new, {})
+
+    expect(rr.dependencies).to eq ['file']
+  end
+
+  it 'releases outputs' do
+    desc = Tataru::BaseResourceDesc.new
+    rr = Tataru::Representations::ResourceRepresentation.new('file', desc, {})
+
+    allow(desc).to receive(:output_fields) { [:created_at] }
+
+    expect(rr.created_at).to be_a(Tataru::Representations::OutputRepresentation)
+    expect(rr.created_at.resource_name).to eq 'file'
+    expect(rr.created_at.output_field_name).to eq :created_at
+  end
+
+  it 'throws error if required field not filled' do
+    desc = Tataru::BaseResourceDesc.new
+    rr = Tataru::Representations::ResourceRepresentation.new('file', desc, {})
+    allow(desc).to receive(:immutable_fields) { [:filename] }
+    allow(desc).to receive(:required_fields) { [:filename] }
+
+    expect { rr.check_required_fields! }.to raise_error "Required field 'filename' not provided in 'file'"
+  end
+
+  it 'throws error when no such output' do
+    desc = Tataru::BaseResourceDesc.new
+    rr = Tataru::Representations::ResourceRepresentation.new('file', desc, {})
+
+    allow(desc).to receive(:output_fields) { [:created_at] }
+
+    expect { rr.updated_at }.to raise_error NoMethodError
+  end
+
+  it 'throws error when no such output' do
+    desc = Tataru::BaseResourceDesc.new
+    allow(desc).to receive(:needs_remote_id?) { false }
+    allow(desc).to receive(:delete_at_end?) { true }
+
+    expect { Tataru::Representations::ResourceRepresentation.new('file', desc, {}) }.to raise_error(
+      'must need remote id if deletes at end'
+    )
+  end
+end

data/spec/resource_dsl_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::ResourceDsl do
+  it 'validates mutable fields' do
+    resource_desc = Tataru::BaseResourceDesc.new
+    allow(resource_desc).to receive(:mutable_fields) { [:filename] }
+
+    dsl = Tataru::ResourceDsl.new('somefile', resource_desc)
+    dsl.filename 'thing'
+
+    expect(dsl.representation).to be_a Tataru::Representations::ResourceRepresentation
+    expect(dsl.representation.properties[:filename]).to be_a Tataru::Representations::LiteralRepresentation
+  end
+
+  it 'validates immutable fields' do
+    resource_desc = Tataru::BaseResourceDesc.new
+    allow(resource_desc).to receive(:immutable_fields) { [:filename] }
+
+    dsl = Tataru::ResourceDsl.new('somefile', resource_desc)
+    dsl.filename 'thing'
+
+    expect(dsl.representation).to be_a Tataru::Representations::ResourceRepresentation
+    expect(dsl.representation.properties[:filename]).to be_a Tataru::Representations::LiteralRepresentation
+  end
+
+  it 'returns an output representation when given an output' do
+    resource_desc = Tataru::BaseResourceDesc.new
+    allow(resource_desc).to receive(:immutable_fields) { [:filename] }
+
+    desc = Tataru::BaseResourceDesc.new
+    rr = Tataru::Representations::ResourceRepresentation.new('other_resource', desc, {})
+    allow(desc).to receive(:output_fields) { [:created_at] }
+
+    dsl = Tataru::ResourceDsl.new('somefile', resource_desc)
+    dsl.filename rr.created_at
+
+    expect(dsl.representation).to be_a Tataru::Representations::ResourceRepresentation
+    expect(dsl.representation.properties[:filename]).to be_a Tataru::Representations::OutputRepresentation
+    expect(dsl.representation.properties[:filename].resource_name).to eq 'other_resource'
+    expect(dsl.representation.properties[:filename].output_field_name).to eq :created_at
+  end
+
+  it 'returns an output representation of remote ID' do
+    resource_desc = Tataru::BaseResourceDesc.new
+    allow(resource_desc).to receive(:immutable_fields) { [:filename] }
+
+
+    desc = Tataru::BaseResourceDesc.new
+    rr = Tataru::Representations::ResourceRepresentation.new('other_resource', desc, {})
+    allow(desc).to receive(:output_fields) { [:created_at] }
+
+
+    dsl = Tataru::ResourceDsl.new('somefile', resource_desc)
+    dsl.filename rr
+
+    expect(dsl.representation).to be_a Tataru::Representations::ResourceRepresentation
+    expect(dsl.representation.properties[:filename]).to be_a Tataru::Representations::OutputRepresentation
+    expect(dsl.representation.properties[:filename].resource_name).to eq 'other_resource'
+    expect(dsl.representation.properties[:filename].output_field_name).to eq :remote_id
+  end
+
+  it 'throws error if nonexistent field' do
+    resource_desc = Tataru::BaseResourceDesc.new
+    allow(resource_desc).to receive(:immutable_fields) { [:filename] }
+
+    dsl = Tataru::ResourceDsl.new('somefile', resource_desc)
+    expect { dsl.age 'thing' }.to raise_error NoMethodError
+  end
+end