spec/model_spec.rb in cistern-2.2.3 vs spec/model_spec.rb in cistern-2.2.4
- old
+ new
@@ -1,45 +1,45 @@
require 'spec_helper'
-describe "Cistern::Model" do
- describe "#update" do
+describe 'Cistern::Model' do
+ describe '#update' do
class UpdateSpec < Sample::Model
identity :id
attribute :name
attribute :properties
def save
attributes
end
end
- it "should merge and save attributes" do
- model = UpdateSpec.new(name: "steve")
+ it 'should merge and save attributes' do
+ model = UpdateSpec.new(name: 'steve')
model.save
- expect(model.update(name: "karen")).to eq(name: "karen")
+ expect(model.update(name: 'karen')).to eq(name: 'karen')
end
end
- context "#new_record?" do
- it "does not require identity" do
+ context '#new_record?' do
+ it 'does not require identity' do
identity_less = Class.new(Sample::Model)
expect(identity_less.new.new_record?).to eq(true)
end
- it "is false if identity is set" do
+ it 'is false if identity is set' do
identity_full = Class.new(Sample::Model) {
identity :id
}
expect(identity_full.new.new_record?).to eq(true)
expect(identity_full.new(id: 1).new_record?).to eq(false)
end
end
- it "should set singular resource service method" do
+ it 'should set singular resource service method' do
class ModelService
include Cistern::Client
end
class ModelService::Jimbob < ModelService::Model
@@ -47,11 +47,11 @@
expect(ModelService.new).to respond_to(:jimbob)
expect(ModelService.new.jimbob).to be_a(ModelService::Jimbob)
end
- it "should set specific singular resource service method" do
+ it 'should set specific singular resource service method' do
class SpecificModelService
include Cistern::Client
end
class SpecificModelService::Jimbob < SpecificModelService::Model
@@ -61,175 +61,175 @@
expect(SpecificModelService.new).not_to respond_to(:jimbob)
expect(SpecificModelService.new).to respond_to(:john_boy)
expect(SpecificModelService.new.john_boy).to be_a(SpecificModelService::Jimbob)
end
- it "should duplicate a model" do
+ it 'should duplicate a model' do
class DupSpec < Sample::Model
identity :id
attribute :name
attribute :properties
end
- model = DupSpec.new(id: 1, name: "string", properties: {value: "something", else: "what"})
+ model = DupSpec.new(id: 1, name: 'string', properties: { value: 'something', else: 'what' })
duplicate = model.dup
expect(duplicate).to eq(model)
expect(duplicate).to eql(model)
- model.name = "anotherstring"
- expect(duplicate.name).to eq("string")
+ model.name = 'anotherstring'
+ expect(duplicate.name).to eq('string')
end
- context "attribute parsing" do
+ context 'attribute parsing' do
class TypeSpec < Sample::Model
identity :id
attribute :name, type: :string
attribute :created_at, type: :time
attribute :flag, type: :boolean
attribute :list, type: :array
attribute :number, type: :integer
attribute :floater, type: :float
- attribute :butternut_id, squash: ["squash", "id"], type: :integer
- attribute :butternut_type, squash: ["squash", "type"]
+ attribute :butternut_id, squash: %w(squash id), type: :integer
+ attribute :butternut_type, squash: %w(squash type)
attribute :squash
- attribute :vegetable, aliases: "squash"
+ attribute :vegetable, aliases: 'squash'
attribute :custom, parser: lambda { |v, _| "X!#{v}" }
- attribute :default, default: "im a squash"
+ attribute :default, default: 'im a squash'
- attribute :same_alias_1, aliases: "nested"
- attribute :same_alias_2, aliases: "nested"
+ attribute :same_alias_1, aliases: 'nested'
+ attribute :same_alias_2, aliases: 'nested'
- attribute :same_alias_squashed_1, squash: ["nested", "attr_1"]
- attribute :same_alias_squashed_2, squash: ["nested", "attr_2"]
- attribute :same_alias_squashed_3, squash: ["nested", "attr_2"]
- attribute :adam_attributes, aliases: "attributes"
+ attribute :same_alias_squashed_1, squash: %w(nested attr_1)
+ attribute :same_alias_squashed_2, squash: %w(nested attr_2)
+ attribute :same_alias_squashed_3, squash: %w(nested attr_2)
+ attribute :adam_attributes, aliases: 'attributes'
def save
requires :flag
end
end
- it "should parse string" do
- expect(TypeSpec.new(name: 1).name).to eq("1")
+ it 'should parse string' do
+ expect(TypeSpec.new(name: 1).name).to eq('1')
end
it "should handle a 'attributes' aliased attribute" do
- expect(TypeSpec.new(attributes: "x").adam_attributes).to eq("x")
+ expect(TypeSpec.new(attributes: 'x').adam_attributes).to eq('x')
end
- it "should parse time" do
+ it 'should parse time' do
time = Time.now
created_at = TypeSpec.new(created_at: time.to_s).created_at
expect(created_at).to be_a(Time)
expect(created_at.to_i).to eq(time.to_i)
end
- it "should parse boolean" do
- expect(TypeSpec.new(flag: "false").flag).to be_falsey
- expect(TypeSpec.new(flag: "true").flag).to be_truthy
+ it 'should parse boolean' do
+ expect(TypeSpec.new(flag: 'false').flag).to be_falsey
+ expect(TypeSpec.new(flag: 'true').flag).to be_truthy
expect(TypeSpec.new(flag: false).flag).to be_falsey
expect(TypeSpec.new(flag: true).flag).to be_truthy
- expect(TypeSpec.new(flag: "0").flag).to be_falsey
- expect(TypeSpec.new(flag: "1").flag).to be_truthy
+ expect(TypeSpec.new(flag: '0').flag).to be_falsey
+ expect(TypeSpec.new(flag: '1').flag).to be_truthy
expect(TypeSpec.new(flag: 0).flag).to be_falsey
expect(TypeSpec.new(flag: 1).flag).to be_truthy
expect(TypeSpec.new(flag: false)).not_to be_flag
expect(TypeSpec.new(flag: true)).to be_flag
end
- it "should parse an array" do
+ it 'should parse an array' do
expect(TypeSpec.new(list: []).list).to eq([])
- expect(TypeSpec.new(list: "item").list).to eq(["item"])
+ expect(TypeSpec.new(list: 'item').list).to eq(['item'])
end
- it "should parse a float" do
- expect(TypeSpec.new(floater: "0.01").floater).to eq(0.01)
+ it 'should parse a float' do
+ expect(TypeSpec.new(floater: '0.01').floater).to eq(0.01)
expect(TypeSpec.new(floater: 0.01).floater).to eq(0.01)
end
- it "should use custom parser" do
- expect(TypeSpec.new(custom: "15").custom).to eq("X!15")
+ it 'should use custom parser' do
+ expect(TypeSpec.new(custom: '15').custom).to eq('X!15')
end
- it "should squash, cast, alias an attribute and keep a vanilla reference" do
+ it 'should squash, cast, alias an attribute and keep a vanilla reference' do
# vanilla squash
- expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).butternut_type).to eq("fred")
- expect(TypeSpec.new({"squash" => {"id" => "12", "type" => nil}}).butternut_type).to be_nil
- expect(TypeSpec.new({"squash" => nil}).butternut_type).to be_nil
+ expect(TypeSpec.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).butternut_type).to eq('fred')
+ expect(TypeSpec.new({ 'squash' => { 'id' => '12', 'type' => nil } }).butternut_type).to be_nil
+ expect(TypeSpec.new({ 'squash' => nil }).butternut_type).to be_nil
# composite processors: squash and cast
- expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).butternut_id).to eq(12)
- expect(TypeSpec.new({"squash" => {"id" => nil, "type" => "fred"}}).butternut_id).to be_nil
- expect(TypeSpec.new({"squash" => {"type" => "fred"}}).butternut_id).to be_nil
+ expect(TypeSpec.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).butternut_id).to eq(12)
+ expect(TypeSpec.new({ 'squash' => { 'id' => nil, 'type' => 'fred' } }).butternut_id).to be_nil
+ expect(TypeSpec.new({ 'squash' => { 'type' => 'fred' } }).butternut_id).to be_nil
# override intermediate processing
- expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).squash).to eq({"id" => "12", "type" => "fred"})
+ expect(TypeSpec.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).squash).to eq({ 'id' => '12', 'type' => 'fred' })
# alias of override
- expect(TypeSpec.new({"squash" => {"id" => "12", "type" => "fred"}}).vegetable).to eq({"id" => "12", "type" => "fred"})
+ expect(TypeSpec.new({ 'squash' => { 'id' => '12', 'type' => 'fred' } }).vegetable).to eq({ 'id' => '12', 'type' => 'fred' })
end
- it "should set a default value" do
- expect(TypeSpec.new.default).to eq("im a squash")
+ it 'should set a default value' do
+ expect(TypeSpec.new.default).to eq('im a squash')
end
- it "should override a default value" do
- expect(TypeSpec.new(default: "now im a different squash").default).to eq("now im a different squash")
+ it 'should override a default value' do
+ expect(TypeSpec.new(default: 'now im a different squash').default).to eq('now im a different squash')
end
- context "allowing the same alias for multiple attributes" do
- it "should do so when not squashing" do
- type_spec = TypeSpec.new({"nested" => "bamboo"})
- expect(type_spec.same_alias_1).to eq("bamboo")
- expect(type_spec.same_alias_2).to eq("bamboo")
+ context 'allowing the same alias for multiple attributes' do
+ it 'should do so when not squashing' do
+ type_spec = TypeSpec.new({ 'nested' => 'bamboo' })
+ expect(type_spec.same_alias_1).to eq('bamboo')
+ expect(type_spec.same_alias_2).to eq('bamboo')
end
- it "should do so when squashing" do
- type_spec = TypeSpec.new({"nested" => {"attr_1" => "bamboo", "attr_2" => "panda"}})
- expect(type_spec.same_alias_squashed_1).to eq("bamboo")
- expect(type_spec.same_alias_squashed_2).to eq("panda")
- expect(type_spec.same_alias_squashed_3).to eq("panda")
+ it 'should do so when squashing' do
+ type_spec = TypeSpec.new({ 'nested' => { 'attr_1' => 'bamboo', 'attr_2' => 'panda' } })
+ expect(type_spec.same_alias_squashed_1).to eq('bamboo')
+ expect(type_spec.same_alias_squashed_2).to eq('panda')
+ expect(type_spec.same_alias_squashed_3).to eq('panda')
end
end
- it "should slice out unaccounted for attributes" do
- expect(TypeSpec.new({"something" => {"id" => "12"}}).attributes.keys).not_to include("something")
+ it 'should slice out unaccounted for attributes' do
+ expect(TypeSpec.new({ 'something' => { 'id' => '12' } }).attributes.keys).not_to include('something')
end
- describe "#requires" do
- it "should raise if attribute not provided" do
- expect { TypeSpec.new({"service" => "fake", "something" => {"id" => "12"}}).save }.to raise_exception(ArgumentError)
+ describe '#requires' do
+ it 'should raise if attribute not provided' do
+ expect { TypeSpec.new({ 'service' => 'fake', 'something' => { 'id' => '12' } }).save }.to raise_exception(ArgumentError)
end
- it "should raise if attribute is provided and is nil" do
- expect { TypeSpec.new({"service" => "fake", "custom" => nil}).save }.to raise_exception(ArgumentError)
+ it 'should raise if attribute is provided and is nil' do
+ expect { TypeSpec.new({ 'service' => 'fake', 'custom' => nil }).save }.to raise_exception(ArgumentError)
end
end
end
- context "attribute coverage info collecting", :coverage do
+ context 'attribute coverage info collecting', :coverage do
class CoverageSpec < Sample::Model
identity :id
attribute :used, type: :string
attribute :unused, type: :string
end
- let!(:obj) { CoverageSpec.new(used: "foo", unused: "bar") }
+ let!(:obj) { CoverageSpec.new(used: 'foo', unused: 'bar') }
before(:each) do
CoverageSpec.attributes[:used][:coverage_hits] = 0
- expect(obj.used).to eq("foo") # once
- expect(obj.used).to eq("foo") # twice
+ expect(obj.used).to eq('foo') # once
+ expect(obj.used).to eq('foo') # twice
end
- it "should store the file path where the attribute was defined" do
+ it 'should store the file path where the attribute was defined' do
expect(CoverageSpec.attributes[:used][:coverage_file]).to eq(__FILE__)
expect(CoverageSpec.attributes[:unused][:coverage_file]).to eq(__FILE__)
end
- it "should store the line number where the attribute was defined" do
+ it 'should store the line number where the attribute was defined' do
src_lines = File.read(__FILE__).lines
expect(src_lines[CoverageSpec.attributes[:used][:coverage_line] - 1]).to match(/attribute :used/)
expect(src_lines[CoverageSpec.attributes[:unused][:coverage_line] - 1]).to match(/attribute :unused/)
end