diametric 0.0.1 → 0.0.2

data/spec/diametric/entity_spec.rb

@@ -9,7 +9,7 @@ describe Diametric::Entity do
     it { should respond_to(:from_query) }
 
     it "should generate a schema" do
-      Person.schema.should == [
+      expected = [
         { :"db/id" => Person.send(:tempid, :"db.part/db"),
           :"db/ident" => :"person/name",
           :"db/valueType" => :"db.type/string",
@@ -49,8 +49,27 @@ describe Diametric::Entity do
           :"db/valueType" => :"db.type/string",
           :"db/cardinality" => :"db.cardinality/one",
           :"db/fulltext" => true,
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/middle_name",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/nicknames",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/many",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => Person.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"person/parent",
+          :"db/valueType" => :"db.type/ref",
+          :"db/cardinality" => :"db.cardinality/many",
+          :"db/doc" => "A person's parent",
           :"db.install/_attribute" => :"db.part/db" }
       ]
+      Person.schema.each do |s|
+        s.should == expected.shift
+      end
     end
   end
 
@@ -67,6 +86,7 @@ describe Diametric::Entity do
       subject.name = "Clinton"
       subject.name.should == "Clinton"
     end
+
   end
 
   describe ".new" do
@@ -79,6 +99,14 @@ describe Diametric::Entity do
       person.name.should == "Dashiell D"
       person.secret_name.should == "Monito"
     end
+
+    it "should defaults attributes" do
+      Person.new.middle_name.should == "Danger"
+    end
+
+    it "should transform default arrays into sets" do
+      Person.new.nicknames.should == Set.new(["Buddy", "Pal"])
+    end
   end
 
   describe ".from_query" do
@@ -91,38 +119,79 @@ describe Diametric::Entity do
   end
 
   describe "#tx_data" do
-    let(:goat) { Goat.new(:name => "Beans", :birthday => Date.parse("2002-04-15"))}
-
-    describe "without a dbid" do
-      it "should generate a transaction with a new tempid" do
-        # Equivalence is currently wrong on EDN tagged values.
-        tx = goat.tx_data.first
-        tx.keys.should == [:"db/id", :"goat/name", :"goat/birthday"]
-        tx[:"db/id"].to_edn.should match(%r"#db/id \[:db.part/user \-\d+\]")
-        tx[:"goat/name"].should == "Beans"
-        tx[:"goat/birthday"].should == goat.birthday
+    context "for an entity with cardinality/many attributes" do
+
+      let(:entity_class) do
+        gen_entity_class(named = "test") do
+          attribute :many, String, :cardinality => :many
+        end
+      end
+
+      describe "with a dbid" do
+        it "should generate a protraction tx for added entries" do
+          entity = entity_class.new(:many => %w|foo bar|)
+          entity.many.should == Set["foo", "bar"]
+          entity.dbid = 1
+          entity.tx_data.should == [[:"db/add", 1, :"test/many", ["foo", "bar"]]]
+        end
+
+        it "should generate a retraction tx for removed entries" do
+          entity = entity_class.new
+          entity.dbid = 1
+          entity.instance_variable_set(:"@changed_attributes", { 'many' => Set["original", "unchanged"]})
+          entity.many = Set["unchanged", "new"]
+          entity.tx_data.should == [
+            [:"db/retract", 1, :"test/many", ["original"]],
+            [:"db/add", 1, :"test/many", ["new"]]
+          ]
+        end
+      end
+
+      describe "without a db/id" do
+        it "should generate a protraction tx" do
+          entity = entity_class.new(:many => %w|foo bar|)
+          tx = entity.tx_data.first
+          tx.should =~ [:"db/add", entity.send(:tempid), :"test/many", ['foo', 'bar']]
+        end
       end
     end
 
-    describe "with a dbid" do
-      it "should generate a transaction with the dbid" do
-        goat.dbid = 1
-        goat.tx_data.should == [
-          { :"db/id" => 1,
-            :"goat/name" => "Beans",
-            :"goat/birthday" => goat.birthday
-          }
-        ]
+    context "for an entity with only cardinality/one attributes" do
+      let(:goat) { Goat.new(:name => "Beans", :birthday => Date.parse("2002-04-15"))}
+
+      describe "without a dbid" do
+        it "should generate a transaction with a new tempid" do
+          # Equivalence is currently wrong on EDN tagged values.
+          tx = goat.tx_data.first
+          tx.keys.should =~ [:"db/id", :"goat/name", :"goat/birthday"]
+          tx[:"db/id"].to_edn.should match(%r"#db/id \[:db.part/user \-\d+\]")
+          tx[:"goat/name"].should == "Beans"
+          tx[:"goat/birthday"].should == goat.birthday
+        end
       end
 
-      it "should generate a transaction with only specified attributes" do
-        goat.dbid = 1
-        goat.tx_data(:name).should == [
-          { :"db/id" => 1,
-            :"goat/name" => "Beans"
-          }
-        ]
+      describe "with a dbid" do
+        it "should generate a transaction with the dbid" do
+          goat.dbid = 1
+          goat.tx_data.should == [
+            { :"db/id" => 1,
+              :"goat/name" => "Beans",
+              :"goat/birthday" => goat.birthday
+            }
+          ]
+        end
+
+        it "should generate a transaction with only specified attributes" do
+          goat.dbid = 1
+          goat.tx_data(:name).should == [
+            { :"db/id" => 1,
+              :"goat/name" => "Beans"
+            }
+          ]
+        end
       end
+
     end
+
   end
 end

data/spec/diametric/persistence/peer_spec.rb

@@ -21,7 +21,7 @@ describe Diametric::Persistence::Peer, :jruby do
   let(:db_uri) { 'datomic:mem://hello' }
 
   it "can connect to a Datomic database" do
-    subject.connect(db_uri)
+    subject.connect(:uri => db_uri)
     subject.connection.should be_a(Java::DatomicPeer::LocalConnection)
   end
 
@@ -29,7 +29,7 @@ describe Diametric::Persistence::Peer, :jruby do
     let(:model_class) { Rat }
 
     before(:all) do
-      subject.connect(db_uri)
+      subject.connect(:uri => db_uri)
       Diametric::Persistence::Peer.create_schemas
     end
   end

data/spec/diametric/persistence/rest_spec.rb

@@ -10,12 +10,19 @@ describe Diametric::Persistence::REST, :integration do
     attribute :age, Integer
   end
 
+  let(:connection_options) do
+    {
+      :uri => db_uri,
+      :storage => storage,
+      :database => dbname
+    }
+  end
   let(:db_uri) { ENV['DATOMIC_URI'] || 'http://localhost:9000' }
-  let(:storage) { ENV['DATOMIC_STORAGE'] || 'test' }
+  let(:storage) { ENV['DATOMIC_STORAGE'] || 'free' }
   let(:dbname) { ENV['DATOMIC_NAME'] || "test-#{Time.now.to_i}" }
 
   it "can connect to a Datomic database" do
-    subject.connect(db_uri, storage, dbname)
+    subject.connect(connection_options)
     subject.connection.should be_a(Datomic::Client)
   end
 
@@ -23,7 +30,7 @@ describe Diametric::Persistence::REST, :integration do
     let(:model_class) { Mouse }
 
     before(:all) do
-      subject.connect(db_uri, storage, dbname)
+      subject.connect(connection_options)
       Diametric::Persistence::REST.create_schemas
     end
   end

data/spec/diametric/persistence_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+# Prevent CRuby from blowing up
+module Diametric
+  module Persistence
+    module Peer
+    end
+  end
+end
+
+describe Diametric::Persistence do
+  let(:settings) { { :uri => 'http://example.com:9000' } }
+  let(:rest_class) { Diametric::Persistence::REST }
+
+  describe ".establish_base_connection" do
+    before { Diametric::Persistence.stub(:persistence_class => rest_class) }
+
+    it "connects" do
+      settings = { :uri => 'http://example.com:9000' }
+      rest_class.should_receive(:connect).with(settings)
+
+      Diametric::Persistence.establish_base_connection(settings)
+    end
+
+    it "records the base persistence class" do
+      rest_class.stub(:connect)
+      Diametric::Persistence.establish_base_connection(settings)
+      Diametric::Persistence.instance_variable_get(:"@_persistence_class").should == rest_class
+    end
+  end
+
+  describe ".included" do
+    before { Diametric::Persistence.stub(:persistence_class => rest_class) }
+
+    it "includes the recorded base persistence class" do
+      class FooEntity; end
+      FooEntity.should_receive(:send).with(:include, rest_class)
+      Diametric::Persistence.instance_variable_set(:"@_persistence_class", rest_class)
+
+      class FooEntity
+        include Diametric::Persistence
+      end
+    end
+  end
+
+  describe ".persistence_class" do
+    it "returns REST for REST-like options" do
+      klass = Diametric::Persistence.persistence_class("http://localhost:9000")
+      klass.should be Diametric::Persistence::REST
+      Diametric::Persistence.rest?.should == true
+    end
+
+    it "returns Peer for Peer-like options", :jruby do
+      klass = Diametric::Persistence.persistence_class("datomic:free://localhost:9000/sample")
+      klass.should be Diametric::Persistence::Peer
+      Diametric::Persistence.peer?.should == true
+    end
+  end
+end

data/spec/diametric/query_spec.rb

@@ -8,6 +8,8 @@ describe Diametric::Query do
       query.where(:age => 2)
       query.conditions.should be_empty
     end
+
+    it "raises when non-searchable conditions (id?) are passed"
   end
 
   describe "#filter" do
@@ -17,6 +19,60 @@ describe Diametric::Query do
     end
   end
 
+  describe "#each" do
+    it "collapses cardinality/many attribute results" do
+      model = gen_entity_class :person do
+        attribute :name, String
+        attribute :likes, String, :cardinality => :many
+      end
+      model.stub(:q => [[1, "Stu", "chocolate"], [1, "Stu", "vanilla"]])
+
+      model.should_receive(:from_query).with([1, "Stu", ["chocolate", "vanilla"]])
+      Diametric::Query.new(model).each {|x| x}
+    end
+  end
+
+  describe "#collapse_results" do
+    let (:model) do
+      gen_entity_class do
+        attribute :name, String
+        attribute :likes, String, :cardinality => :many
+      end
+    end
+    let(:query) { Diametric::Query.new(model) }
+
+    context "with multiple results per entity" do
+      it "collapses cardinality/many attributes into lists" do
+        results = [[1, "Stu", "chocolate"], [1, "Stu", "vanilla"], [1, "Stu", "raspberry"]]
+        collapsed = query.send(:collapse_results, results).first
+        collapsed.should == [1, "Stu", ["chocolate", "vanilla", "raspberry"]]
+      end
+    end
+
+    context "with single result per entity" do
+      it "collapses cardinality/many attributes into lists" do
+        results = [[1, "Stu", "chocolate"]]
+        collapsed = query.send(:collapse_results, results).first
+        collapsed.should == [1, "Stu", ["chocolate"]]
+      end
+    end
+  end
+
+  describe "#all" do
+    it "returns set for values of cardinality/many" do
+      model = gen_entity_class :person do
+        attribute :name, String
+        attribute :likes, String, :cardinality => :many
+      end
+      model.stub(:q => [[1, "Stu", "chocolate"], [1, "Stu", "vanilla"]])
+      Diametric::Query.new(model).all.each do |e|
+        e.name.should == "Stu"
+        e.likes.class.should == Set
+        e.likes.should include "chocolate"
+        e.likes.should include "vanilla"
+      end
+    end
+  end
 
   describe "#data" do
     it "should generate a query given no conditions or filters" do

data/spec/integration_spec.rb

@@ -7,7 +7,7 @@ require 'datomic/client'
 describe Diametric::Entity, :integration => true do
   before(:all) do
     @datomic_uri = ENV['DATOMIC_URI'] || 'http://localhost:9000'
-    @storage = ENV['DATOMIC_STORAGE'] || 'test'
+    @storage = ENV['DATOMIC_STORAGE'] || 'free'
     @dbname = ENV['DATOMIC_NAME'] || "test-#{Time.now.to_i}"
     @client = Datomic::Client.new @datomic_uri, @storage
     @client.create_database(@dbname)
@@ -64,4 +64,32 @@ describe Diametric::Entity, :integration => true do
     end
   end
 
+  describe "with persistence module" do
+    before(:all) do
+      Robin.create_schema
+    end
+
+    let(:query) { Diametric::Query.new(Robin) }
+    it "can update entity" do
+      robin = Robin.new(:name => "Mary", :age => 2)
+      robin.save
+      robin.update(:age => 3)
+      robin.name.should == "Mary"
+      robin.age.should == 3
+    end
+    it "should search upadated attributes" do
+      robin = query.where(:name => "Mary").first
+      robin.name.should == "Mary"
+      robin.age.should == 3
+    end
+    it "can destroy entity" do
+      robin = Robin.new(:name => "Mary", :age => 2)
+      robin.save
+      number_of_robins = Robin.all.size
+      number_of_robins.should >= 1
+      robin.destroy
+      Robin.all.size.should == (number_of_robins -1)
+    end
+  end
+
 end

data/spec/peer_integration_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'datomic/client'
+
+# Datomic's `rest` needs to run for these tests to pass:
+#   bin/rest 9000 test datomic:mem://
+
+describe Diametric::Entity, :integration => true, :jruby => true do
+  before(:all) do
+    @datomic_uri = ENV['DATOMIC_URI'] || 'datomic:mem://animals'
+    Diametric::Persistence.establish_base_connection({:uri => @datomic_uri})
+    Penguin.create_schema
+  end
+
+  let(:query) { Diametric::Query.new(Penguin) }
+  it "should update entity" do
+    penguin = Penguin.new(:name => "Mary", :age => 2)
+    penguin.save
+    penguin.update(:age => 3)
+    penguin.name.should == "Mary"
+    penguin.age.should == 3
+  end
+
+  it "should search upadated attributes" do
+    penguin = query.where(:name => "Mary").first
+    penguin.name.should == "Mary"
+    penguin.age.should == 3
+  end
+
+  it "should destroy entity" do
+    penguin = Penguin.new(:name => "Mary", :age => 2)
+    penguin.save
+    number_of_penguins = Penguin.all.size
+    number_of_penguins.should >= 1
+    penguin.destroy
+    Penguin.all.size.should == (number_of_penguins -1)
+  end
+end

data/spec/spec_helper.rb

@@ -43,6 +43,9 @@ class Person
   attribute :ssn, String, :unique => :value
   attribute :secret_name, String, :unique => :identity
   attribute :bio, String, :fulltext => true
+  attribute :middle_name, String, :default => "Danger"
+  attribute :nicknames, String, :cardinality => :many, :default => ["Buddy", "Pal"]
+  attribute :parent, Ref, :cardinality => :many, :doc => "A person's parent"
 end
 
 class Goat
@@ -51,3 +54,23 @@ class Goat
   attribute :name, String
   attribute :birthday, DateTime
 end
+
+require 'diametric/persistence/rest'
+class Robin
+  include Diametric::Entity
+  include Diametric::Persistence::REST
+
+  attribute :name, String
+  attribute :age, Integer
+end
+
+if RUBY_ENGINE == "jruby"
+  require 'diametric/persistence/peer'
+  class Penguin
+    include Diametric::Entity
+    include Diametric::Persistence::Peer
+
+    attribute :name, String
+    attribute :age, Integer
+  end
+end