opal-vienna 0.7.0

data/spec/model/accessing_attributes_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class AccessingAttributesSpec < Vienna::Model
+  attributes :first_name, :last_name
+
+  def last_name=(name)
+    raise "Cannot set last_name"
+  end
+end
+
+describe Vienna::Model do
+
+  let(:model) { AccessingAttributesSpec.new }
+
+  describe "#[]" do
+    it "retrieves attributes from the model" do
+      model[:first_name].should be_nil
+      model.first_name = "Adam"
+      model[:first_name].should eq("Adam")
+    end
+  end
+
+  describe "#[]=" do
+    it "sets attributes on the model" do
+      model[:first_name] = "Adam"
+      model.first_name.should eq("Adam")
+    end
+  end
+end

data/spec/model/as_json_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Vienna::Model do
+  describe "#as_json" do
+    let(:model) { User.new }
+
+    it "returns a hash" do
+      expect(model.as_json).to be_kind_of(Hash)
+    end
+
+    it "contains all attributes on model" do
+      expect(model.as_json).to eq({ "foo" => nil, "bar" => nil, "baz" => nil })
+
+      model.foo = "Adam"
+      expect(model.as_json).to eq({ "foo" => "Adam", "bar" => nil, "baz" => nil })
+
+      model.bar = "Beynon"
+
+      expect(model.as_json).to eq({ "foo" => "Adam", "bar" => "Beynon", "baz" => nil })
+    end
+
+    it "includes the id, if set" do
+      model.id = 42
+
+      expect(model.as_json).to eq({ "id" => 42, "foo" => nil, "bar" => nil, "baz" => nil })
+    end
+  end
+end

data/spec/model/attribute_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Vienna::Model do
+  describe ".attribute" do
+    let(:model) { User.new }
+
+    it "should create a reader method for attribute" do
+      expect(model).to respond_to(:foo)
+    end
+
+    it "should create a writer method for attribute" do
+      expect(model).to respond_to(:foo=)
+    end
+
+    describe "writer" do
+      it "sets value on model" do
+        model.foo = 'Tommy'
+        expect(model.foo).to eq('Tommy')
+      end
+    end
+  end
+end

data/spec/model/initialize_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Vienna::Model do
+  describe "#initialize" do
+    it "should have all nil values for attributes when passed no attrs" do
+      model = User.new
+
+      expect(model.foo).to be_nil
+      expect(model.bar).to be_nil
+      expect(model.baz).to be_nil
+    end
+
+    it "should set a given value for a given attributes" do
+      model = User.new foo: 3.142
+
+      expect(model.foo).to eq(3.142)
+      expect(model.bar).to be_nil
+      expect(model.baz).to be_nil
+    end
+
+    it "should be able to set many attributes" do
+      model = User.new foo: 'hello', bar: 'world', baz: 42
+
+      expect(model.foo).to eq('hello')
+      expect(model.bar).to eq('world')
+      expect(model.baz).to eq(42)
+    end
+
+    it "creates @attributes as an empty hash" do
+      model = User.new
+      model.instance_variable_get(:@attributes).should eq({})
+    end
+
+    it "marks the model as being a new record" do
+      expect(User.new).to be_new_record
+    end
+
+    it "marks the model as not being loaded" do
+      expect(User.new).to_not be_loaded
+    end
+  end
+end

data/spec/model/load_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Vienna::Model do
+  describe "#load" do
+    let(:model) { SimpleModel.new }
+
+    it "marks the model instance as loaded" do
+      model.load({})
+      expect(model).to be_loaded
+    end
+
+    it "marks the model as not being a new record" do
+      model.load({})
+      expect(model).to_not be_new_record
+    end
+  end
+end

data/spec/model/persistence_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Vienna::Model do
+  let(:model_class) { SimpleModel }
+  let(:model) { model_class.new }
+  let(:loaded_model) { model_class.load(:first_name => "Adam", id: 872) }
+  describe "#did_destroy" do
+    it "triggers a :destroy event on the record" do
+      called = false
+      model.on(:destroy) { called = true }
+      model.did_destroy
+      called.should eq(true)
+    end
+
+    it "triggers a :destroy event on the class" do
+      called = false
+      model_class.on(:destroy) { called = true }
+      model.did_destroy
+      called.should eq(true)
+    end
+
+    it "removes the record from the class identity_map" do
+      loaded_model.did_destroy
+      model_class.identity_map[loaded_model.id].should eq(nil)
+    end
+
+    it "removes the record from the class record_array" do
+      loaded_model.did_destroy
+      model_class.all.should_not include(loaded_model)
+    end
+  end
+
+  describe '#destroyed?' do
+    it 'is false for "living" models' do
+      model.destroyed?.should be_falsey
+    end
+
+    it "is true for destroyed models" do
+      loaded_model.did_destroy
+      loaded_model.destroyed?.should be_truthy
+    end
+  end
+
+  describe "#did_create" do
+    it "sets @new_record to false" do
+      model.did_create
+      model.new_record?.should eq(false)
+    end
+
+    it "adds record to class identity_map" do
+      model.id = 863
+      model.did_create
+      model.class.identity_map[863].should eq(model)
+    end
+
+    it "adds record to class record array" do
+      model.class.all.should == []
+      model.did_create
+      model.class.all.should == [model]
+    end
+
+    it "triggers a :create event on the record" do
+      called = false
+      model.on(:create) { called = true }
+      model.did_create
+      called.should eq(true)
+    end
+
+    it "triggers a :create event on the class" do
+      called = false
+      model.class.on(:create) { called = true }
+      model.did_create
+      called.should eq(true)
+    end
+  end
+
+  describe ".all" do
+    it "is a record array of all models" do
+      model.class.all.should == []
+      model.did_create
+      model.class.all.should == [model]
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Vienna::Model do
+  describe ".new" do
+    it "should set @new_record to true" do
+      SimpleModel.new.new_record?.should eq(true)
+    end
+  end
+
+  describe ".primary_key" do
+    it "should have a default primary key" do
+      SimpleModel.primary_key.should eq(:id)
+    end
+
+    it "should be changeable" do
+      AdvancedModel.primary_key.should eq(:title)
+    end
+  end
+
+  describe ".load" do
+    it "raises an ArgumentError if no id present" do
+      lambda {
+        SimpleModel.load({})
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should be able to load models with own primary_key" do
+      AdvancedModel.load(title: 100).should be_kind_of(AdvancedModel)
+    end
+
+    it "should set @new_record to false on the model" do
+      model = SimpleModel.load(id: 42)
+      model.new_record?.should eq(false)
+    end
+
+    it "should cache model" do
+      SimpleModel.identity_map[8].should be_nil
+      model = SimpleModel.load(id: 8)
+      SimpleModel.identity_map[8].should eq(model)
+    end
+
+    it "saves the model in .all record array" do
+      SimpleModel.all.should == []
+      model = SimpleModel.load(id: 10)
+      SimpleModel.all.should == [model]
+    end
+
+    it "should update existing models" do
+      foo = SimpleModel.load(id: 9, name: 'Adam')
+      bar = SimpleModel.load(id: 9, name: 'Beynon')
+      foo.should equal(bar)
+      foo.name.should eq("Beynon")
+    end
+  end
+
+  describe ".load_json" do
+    it "should load a model from native json/js object" do
+      obj = `{"id": 13, "name": "Bob"}`
+      model = SimpleModel.load_json obj
+      model.id.should eq(13)
+      model.name.should eq("Bob")
+    end
+  end
+
+  describe ".adapter" do
+    it "sets a new instance of the passed adapter as @adapter" do
+      klass = Class.new(Vienna::Model) do
+        adapter Vienna::Adapter
+      end
+
+      klass.instance_variable_get(:@adapter).should be_kind_of(Vienna::Adapter)
+    end
+
+    it "returns the adapter set on the model subclass" do
+      klass = Class.new(Vienna::Model) { adapter Vienna::Adapter }
+      klass.adapter.should be_kind_of(Vienna::Adapter)
+    end
+
+    it "raises an error when no adapter set on model subclass" do
+      klass = Class.new(Vienna::Model)
+      lambda { klass.adapter }.should raise_error(Exception)
+    end
+  end
+end

data/spec/observable_array_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'vienna/observable_array'
+
+class ObservableArraySpec
+  include Vienna::ObservableArray
+end
+
+describe Vienna::ObservableArray do
+  let(:klass) { ObservableArraySpec }
+  let(:empty) { klass.new }
+  let(:foobar) { klass.new([:foo, :bar]) }
+
+  describe ".new" do
+    it "takes an optional content" do
+      klass.new.content.should == []
+      klass.new([1, 2, 3]).content.should == [1, 2, 3]
+    end
+  end
+
+  describe "#<<" do
+    it "pushes each object into the content" do
+      empty << :foo
+      empty << :bar
+      empty << :baz
+
+      empty.content.should == [:foo, :bar, :baz]
+    end
+
+    it "generates a change event for starting index and single added item" do
+      expect(empty).to receive(:array_content_did_change).once.with(0, 0, 1)
+      empty << :some_object
+
+      expect(foobar).to receive(:array_content_did_change).once.with(2, 0, 1)
+      foobar << :other_object
+    end
+  end
+
+  describe "#delete" do
+    it "deletes the object from the content array" do
+      foobar.delete :foo
+      foobar.content.should == [:bar]
+    end
+
+    it "notifies observers with single remove object" do
+      expect(foobar).to receive(:array_content_did_change).once.with(1, 1, 0)
+      foobar.delete :bar
+    end
+
+    it "has no effect when object not present" do
+      expect(foobar).to_not receive(:array_content_did_change)
+      foobar.delete :baz
+    end
+  end
+
+  describe "#insert" do
+    it "adds the object to the content array at specified index" do
+      empty.insert 0, :foo
+      empty.content.should == [:foo]
+
+      foobar.insert 1, :baz
+      foobar.content.should == [:foo, :baz, :bar]
+    end
+
+    it "notifies observers with single added object at index" do
+      expect(empty).to receive(:array_content_did_change).once.with(0, 0, 1)
+      empty.insert 0, :omg
+
+      expect(foobar).to receive(:array_content_did_change).once.with(1, 0, 1)
+      foobar.insert 1, :wow
+    end
+
+    it "raises an ArgumentError for index out of range" do
+      expect { empty.insert 2, :foo }.to raise_error(ArgumentError)
+      expect { foobar.insert 90, :foo }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#clear" do
+    it "removes all items from the content array" do
+      empty.clear
+      empty.content.should == []
+
+      foobar.clear
+      foobar.content.should == []
+    end
+
+    it "notifies observers to remove all existing objects" do
+      expect(empty).to receive(:array_content_did_change).once.with(0, 0, 0)
+      empty.clear
+
+      expect(foobar).to receive(:array_content_did_change).once.with(0, 2, 0)
+      foobar.clear
+    end
+  end
+
+  describe "#array_content_did_change" do
+    it "triggers a :size attribute change" do
+      called = false
+      empty.add_observer(:size) { called = true }
+      empty.clear
+
+      called.should == true
+    end
+
+    it "triggers a :content attribute change" do
+      called = false
+      empty.add_observer(:content) { called = true }
+      empty.clear
+
+      called.should == true
+    end
+
+    it "triggers a :empty? attribute change" do
+      called = false
+      empty.add_observer(:empty?) { called = true }
+      empty.clear
+
+      called.should == true
+    end
+
+    it "notifies each observer added using add_array_observer" do
+      observer = double(:observer)
+      expect(observer).to receive(:array_did_change).once.with(empty, 0, 0, 0)
+
+      empty.add_array_observer observer
+
+      empty.clear
+    end
+  end
+end

data/spec/observable_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'vienna/observable'
+
+class ObservableSpec
+  include Vienna::Observable
+
+  attr_accessor :foo, :bar, :baz
+
+  def baz=(b)
+    @baz = b + 10
+  end
+
+  def bar=(b)
+    @bar = b
+    "#bar"
+  end
+end
+
+describe Vienna::Observable do
+
+  let(:object) { ObservableSpec.new }
+
+  describe "#replace_writer_for" do
+    it "still calls the original method using super" do
+      object.replace_writer_for(:foo)
+      object.baz = 100
+      object.baz.should eq(110)
+    end
+
+    it "does not add a setter unless an existing attribute= method exists" do
+      object.replace_writer_for(:bob)
+      object.should_not respond_to(:bob=)
+    end
+
+    it "the new writer calls attribute_did_change with attribute name" do
+      object.replace_writer_for(:foo)
+      def object.attribute_did_change(attribute); @_called = attribute; end
+
+      object.instance_variable_get(:@_called).should be_nil
+      object.foo = 100
+      object.instance_variable_get(:@_called).should eq(:foo)
+    end
+  end
+
+  describe "#add_observer" do
+    it "handlers can be added to observe specific attributes" do
+      count = 0
+      object.add_observer(:foo) { count += 1 }
+
+      object.foo = 100
+      count.should eq(1)
+
+      object.foo = 150
+      count.should eq(2)
+    end
+
+    it "allows more than one handler to be added for an attribute" do
+      result = []
+      object.add_observer(:foo) { result << :first }
+      object.add_observer(:foo) { result << :second }
+
+      object.foo = 42
+      result.should eq([:first, :second])
+
+      object.foo = 3.142
+      result.should eq([:first, :second, :first, :second])
+    end
+  end
+
+  describe "#attribute_did_change" do
+    it "does not break for an object with no observers" do
+      object.attribute_did_change(:foo_bar)
+    end
+
+    it "does not break when given an attriubte with no observers (but another observable exists)" do
+      object.add_observer(:foo) {}
+      object.attribute_did_change(:bar)
+    end
+
+    it "passes new value to each handler" do
+      result = nil
+      object.add_observer(:foo) { |val| result = val }
+
+      object.foo = 42
+      result.should eq(42)
+
+      object.foo = 3.142
+      result.should eq(3.142)
+    end
+  end
+
+  describe "#remove_observer" do
+    it "has no effect when no observers setup for attribute" do
+      object.remove_observer(:foo, proc {})
+    end
+
+    it "has no effect if the handler doesnt exist for attribute" do
+      p = proc {}
+      object.add_observer(:foo) {}
+      object.remove_observer(:foo, p)
+    end
+
+    it "removes an existing handler for given attribute" do
+      count = 0
+      handler = proc { count += 1 }
+      object.add_observer(:foo, &handler)
+
+      object.foo = 42
+      count.should eq(1)
+
+      object.remove_observer(:foo, handler)
+      object.foo = 49
+      count.should eq(1)
+    end
+  end
+end