diametric 0.0.4 → 0.1.1

data/spec/developer_create_sample.rb

@@ -0,0 +1,39 @@
+require 'conf_helper'
+
+class Developer
+  include Diametric::Entity
+  include Diametric::Persistence::Peer
+
+  attribute :name, String
+  attribute :friends, Ref, :cardinality => :many
+end
+
+describe "RailsConf 2013", :jruby => true do
+  context Developer do
+    before(:all) do
+      datomic_uri = "datomic:mem://developer-#{SecureRandom.uuid}"
+      @conn = Diametric::Persistence::Peer.connect(datomic_uri)
+    end
+    after(:all) do
+      @conn.release
+    end
+
+    it "should create schema and save instaces" do
+      binding.pry
+      Developer.create_schema(@conn)
+
+      yoko = Developer.new
+      yoko.name = "Yoko Harada"
+      yoko.save
+      binding.pry
+
+      clinton = Developer.new(:name => "Clinton N. Dreisbach", :friends => [yoko])
+      clinton.save
+      binding.pry
+
+      ryan = Developer.new(:name => "Ryan Neufeld", :friends => [clinton, yoko])
+      ryan.save
+      binding.pry
+    end
+  end
+end

data/spec/developer_query_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+class Developer
+  include Diametric::Entity
+  include Diametric::Persistence::Peer
+
+  attribute :name, String
+  attribute :nerd_rate, Integer
+  attribute :friends, Ref, :cardinality => :many
+end
+
+describe Developer, :jruby => true do
+  before do
+    datomic_uri = "datomic:mem://developer-#{SecureRandom.uuid}"
+    @conn = Diametric::Persistence::Peer.connect(datomic_uri)
+    Developer.create_schema(@conn)
+  end
+  after do
+    @conn.release
+  end
+
+  it "should save an instace and get it" do
+    yoko = Developer.new
+    yoko.name = "Yoko Harada"
+    yoko.save(@conn)
+    query = Diametric::Query.new(Developer, @conn, true)
+    result = query.all
+    result.size.should == 1
+    result.first.name.should == "Yoko Harada"
+  end
+
+  it "should make query with the argument" do
+    yoko = Developer.new
+    yoko.name = "Yoko Harada"
+    yoko.nerd_rate = 50
+    yoko.save(@conn)
+    query = Diametric::Query.new(Developer, @conn, true).where(:name => "Yoko Harada")
+    query_data = "[:find ?e :in $ [?name] :where [?e :developer/name ?name]]"
+    query.data.first.gsub(" ", "").should == query_data.gsub(" ", "")
+    result = query.all
+    result.size.should == 1
+    result.first.nerd_rate.should == 50
+  end
+
+  it "should not resolve referenced object" do
+    yoko = Developer.new
+    yoko.name = "Yoko Harada"
+    yoko.nerd_rate = 50
+    yoko.save(@conn)
+    clinton = Developer.new(:name => "Clinton N. Dreisbach", :friends => [yoko])
+    clinton.nerd_rate = 98
+    clinton.save(@conn)
+
+    query = Diametric::Query.new(Developer, @conn).where(:name => "Clinton N. Dreisbach")
+    result = query.all
+    result.size.should == 1
+
+    developer = Developer.from_dbid_or_entity(result.first, @conn.db, false)
+    friends = developer.friends
+    friends.each do |f|
+      f.should be_a(Java::DatomicQuery::EntityMap)
+    end
+  end
+
+  it "should find three developers" do
+    yoko = Developer.new
+    yoko.name = "Yoko Harada"
+    yoko.nerd_rate = 50
+    yoko.save(@conn)
+    clinton = Developer.new(:name => "Clinton N. Dreisbach", :friends => [yoko])
+    clinton.nerd_rate = 98
+    clinton.save(@conn)
+    ryan = Developer.new(:name => "Ryan Neufeld", :friends => [clinton, yoko])
+    ryan.nerd_rate = 80
+    ryan.save(@conn)
+
+    query = Diametric::Query.new(Developer, @conn)
+    result = query.all
+    result.size.should == 3
+    resolved_result = result.map {|m| Developer.from_dbid_or_entity(m, @conn)}
+    resolved_result.collect(&:nerd_rate).should =~ [50, 98, 80]
+  end
+
+  it "should filter out developers" do
+    yoko = Developer.new
+    yoko.name = "Yoko Harada"
+    yoko.nerd_rate = 50
+    yoko.save(@conn)
+    clinton = Developer.new(:name => "Clinton N. Dreisbach", :friends => [yoko])
+    clinton.nerd_rate = 98
+    clinton.save(@conn)
+    ryan = Developer.new(:name => "Ryan Neufeld", :friends => [clinton, yoko])
+    ryan.nerd_rate = 80
+    ryan.save(@conn)
+
+    query = Diametric::Query.new(Developer, @conn).filter(:>, :nerd_rate, 70)
+    query_data = "[:find ?e :in $ :where [?e :developer/nerd_rate ?nerd_rate] [(> ?nerd_rate 70)]]"
+    query.data.first.gsub(" ", "").should == query_data.gsub(" ", "")
+    result = query.all
+    result.size.should == 2
+  end
+
+  it "should resolve referenced objects" do
+    yoko = Developer.new
+    yoko.name = "Yoko Harada"
+    yoko.nerd_rate = 50
+    yoko.save(@conn)
+    clinton = Developer.new(:name => "Clinton N. Dreisbach", :friends => [yoko])
+    clinton.nerd_rate = 98
+    clinton.save(@conn)
+    ryan = Developer.new(:name => "Ryan Neufeld", :friends => [clinton, yoko])
+    ryan.nerd_rate = 80
+    ryan.save(@conn)
+
+    query = Diametric::Query.new(Developer, @conn, true).where(:name => "Ryan Neufeld")
+    result = query.all
+    result.size.should == 1
+    result.first.friends.collect(&:name).should =~ ["Yoko Harada", "Clinton N. Dreisbach"]
+  end
+end

data/spec/diametric/config_spec.rb

@@ -52,7 +52,7 @@ describe Diametric::Config do
 
   describe ".connect!" do
     it "establishes a base connection" do
-      settings = stub
+      settings = double
       Diametric::Persistence.should_receive(:establish_base_connection).with(settings)
       Diametric::Config.connect!(settings)
     end

data/spec/diametric/entity_spec.rb

@@ -1,4 +1,30 @@
 require 'spec_helper'
+require 'diametric/entity'
+
+require 'rspec/expectations'
+
+RSpec::Matchers.define :be_an_equivalent_hash do |expected|
+  match do |actual|
+    status = true
+    expected.each do |k, v|
+      next if k == ":db/id"
+      status = false if actual[k].nil?
+      status = false unless actual[k] == v
+    end
+    status
+  end
+end
+
+RSpec::Matchers.define :be_an_equivalent_array do |expected|
+  match do |actual|
+    status = true
+    expected.each_with_index do |e, index|
+      next if e == "#db/id[:db.part/user]"
+      status = false unless actual[index] == e
+    end
+    status
+  end
+end
 
 describe Diametric::Entity do
   describe "in a class" do
@@ -210,4 +236,241 @@ describe Diametric::Entity do
     end
 
   end
+
+  context "boolean type" do
+    subject { Choice }
+
+    it "should generate a schema" do
+      expected = []
+      if is_jruby?
+        expected = [
+                    { ":db/id" => subject.send(:tempid, ":db.part/db"),
+                      ":db/ident" => ":choice/item",
+                      ":db/valueType" => ":db.type/string",
+                      ":db/cardinality" => ":db.cardinality/one",
+                      ":db.install/_attribute" => ":db.part/db" },
+                    { ":db/id" => subject.send(:tempid, ":db.part/db"),
+                      ":db/ident" => ":choice/checked",
+                      ":db/valueType" => ":db.type/boolean",
+                      ":db/cardinality" => ":db.cardinality/one",
+                      ":db.install/_attribute" => ":db.part/db" }
+                   ]
+      else
+        expected = [
+                    { :"db/id" => subject.send(:tempid, :"db.part/db"),
+                      :"db/ident" => :"choice/item",
+                      :"db/valueType" => :"db.type/string",
+                      :"db/cardinality" => :"db.cardinality/one",
+                      :"db.install/_attribute" => :"db.part/db" },
+                    { :"db/id" => subject.send(:tempid, :"db.part/db"),
+                      :"db/ident" => :"choice/checked",
+                      :"db/valueType" => :"db.type/boolean",
+                      :"db/cardinality" => :"db.cardinality/one",
+                      :"db.install/_attribute" => :"db.part/db" }
+                   ]
+      end
+      @created_schema = subject.schema
+      expected.each do |e|
+        @created_schema.shift.should be_an_equivalent_hash(e)
+      end
+    end
+  end
+
+  context "uuid type" do
+    subject { Customer }
+
+    it "should generate a schema" do
+      expected = []
+      if is_jruby?
+        expected = [
+                    { ":db/id" => subject.send(:tempid, ":db.part/db"),
+                      ":db/ident" => ":customer/name",
+                      ":db/valueType" => ":db.type/string",
+                      ":db/cardinality" => ":db.cardinality/one",
+                      ":db.install/_attribute" => ":db.part/db" },
+                    { ":db/id" => subject.send(:tempid, ":db.part/db"),
+                      ":db/ident" => ":customer/id",
+                      ":db/valueType" => ":db.type/uuid",
+                      ":db/cardinality" => ":db.cardinality/one",
+                      ":db.install/_attribute" => ":db.part/db" }
+                   ]
+      else
+        expected = [
+                    { :"db/id" => subject.send(:tempid, :"db.part/db"),
+                      :"db/ident" => :"customer/name",
+                      :"db/valueType" => :"db.type/string",
+                      :"db/cardinality" => :"db.cardinality/one",
+                      :"db.install/_attribute" => :"db.part/db" },
+                    { :"db/id" => subject.send(:tempid, :"db.part/db"),
+                      :"db/ident" => :"customer/id",
+                      :"db/valueType" => :"db.type/uuid",
+                      :"db/cardinality" => :"db.cardinality/one",
+                      :"db.install/_attribute" => :"db.part/db" }
+                   ]
+      end
+      @created_schema = subject.schema
+      expected.each do |e|
+        @created_schema.shift.should be_an_equivalent_hash(e)
+      end
+    end
+  end
+
+  context "Float, Double type" do
+    subject { Account }
+
+    it "should generate a schema" do
+      expected = []
+      if is_jruby?
+        expected = [
+                    { ":db/id" => subject.send(:tempid, ":db.part/db"),
+                      ":db/ident" => ":account/name",
+                      ":db/valueType" => ":db.type/string",
+                      ":db/cardinality" => ":db.cardinality/one",
+                      ":db.install/_attribute" => ":db.part/db" },
+                    { ":db/id" => subject.send(:tempid, ":db.part/db"),
+                      ":db/ident" => ":account/deposit",
+                      ":db/valueType" => ":db.type/double",
+                      ":db/cardinality" => ":db.cardinality/many",
+                      ":db.install/_attribute" => ":db.part/db" },
+                    { ":db/id" => subject.send(:tempid, ":db.part/db"),
+                      ":db/ident" => ":account/amount",
+                      ":db/valueType" => ":db.type/double",
+                      ":db/cardinality" => ":db.cardinality/one",
+                      ":db.install/_attribute" => ":db.part/db" }
+                   ]
+      else
+        expected = [
+                    { :"db/id" => subject.send(:tempid, :"db.part/db"),
+                      :"db/ident" => :"account/name",
+                      :"db/valueType" => :"db.type/string",
+                      :"db/cardinality" => :"db.cardinality/one",
+                      :"db.install/_attribute" => :"db.part/db" },
+                    { :"db/id" => subject.send(:tempid, :"db.part/db"),
+                      :"db/ident" => :"account/deposit",
+                      :"db/valueType" => :"db.type/double",
+                      :"db/cardinality" => :"db.cardinality/many",
+                      :"db.install/_attribute" => :"db.part/db" },
+                    { :"db/id" => subject.send(:tempid, :"db.part/db"),
+                      :"db/ident" => :"account/amount",
+                      :"db/valueType" => :"db.type/double",
+                      :"db/cardinality" => :"db.cardinality/one",
+                      :"db.install/_attribute" => :"db.part/db" }
+                   ]
+      end
+      @created_schema = subject.schema
+      expected.each do |e|
+        @created_schema.shift.should be_an_equivalent_hash(e)
+      end
+    end
+  end
+
+  context "community sample" do
+    subject { Organization }
+
+    it { should respond_to(:attribute) }
+    it { should respond_to(:enum) }
+    it { should respond_to(:schema) }
+
+    it "should generate a schema" do
+      expected = [
+        { :"db/id" => subject.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"organization/name",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/fulltext" => true,
+          :"db/doc" => "A organization's name",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => subject.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"organization/url",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/doc" => "A organization's url",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => subject.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"organization/neighborhood",
+          :"db/valueType" => :"db.type/ref",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/doc" => "A organization's neighborhood",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => subject.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"organization/category",
+          :"db/valueType" => :"db.type/string",
+          :"db/cardinality" => :"db.cardinality/many",
+          :"db/fulltext" => true,
+          :"db/doc" => "All organization categories",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => subject.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"organization/orgtype",
+          :"db/valueType" => :"db.type/ref",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/doc" => "A organization orgtype enum value",
+          :"db.install/_attribute" => :"db.part/db" },
+        { :"db/id" => subject.send(:tempid, :"db.part/db"),
+          :"db/ident" => :"organization/type",
+          :"db/valueType" => :"db.type/ref",
+          :"db/cardinality" => :"db.cardinality/one",
+          :"db/doc" => "A organization type enum value",
+          :"db.install/_attribute" => :"db.part/db" },
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.orgtype/community" ],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.orgtype/commercial" ],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.orgtype/nonprofit"],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.orgtype/personal"],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/email-list"],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/twitter"],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/facebook-page" ],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/blog" ],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/website" ],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/wiki" ],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/myspace" ],
+        [ :"db/add", subject.send(:tempid, :"db.part/user"), :"db/ident", :"organization.type/ning"]
+      ]
+
+      @created_schema = Organization.schema
+      expected.each do |e|
+        @created_schema.shift.should == e
+      end
+    end
+  end
+
+
+  context "seattle sample", :jruby do
+    describe Diametric::Entity do
+      subject { District }
+
+      it "should create peer schema" do
+        expected = [
+        { ":db/id" => subject.send(:tempid, ":db.part/db"),
+          ":db/ident" => ":district/name",
+          ":db/valueType" => ":db.type/string",
+          ":db/cardinality" => ":db.cardinality/one",
+          ":db/unique" => ":db.unique/identity",
+          ":db/doc" => "A unique district name (upsertable)",
+          ":db.install/_attribute" => ":db.part/db" },
+        { ":db/id" => subject.send(:tempid, ":db.part/db"),
+          ":db/ident" => ":district/region",
+          ":db/valueType" => ":db.type/ref",
+          ":db/cardinality" => ":db.cardinality/one",
+          ":db/doc" => "A district region enum value",
+          ":db.install/_attribute" => ":db.part/db" },
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/n"],
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/ne"],
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/e"],
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/se"],
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/s"],
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/sw"],
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/w"],
+        [ ":db/add", "#db/id[:db.part/user]", ":db/ident", ":district.region/nw"]
+      ]
+        @created_schema = District.schema
+        expected.each do |e|
+          if e.is_a? Hash
+            @created_schema.shift.should be_an_equivalent_hash(e)
+          else
+            @created_schema.shift.should be_an_equivalent_array(e)
+          end
+        end
+      end
+    end
+  end
+
 end

data/spec/diametric/peer_api_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'securerandom'
+
+if is_jruby?
+  describe Diametric::Persistence::Peer, :jruby => true do
+    @db_name = "test-#{SecureRandom.uuid}"
+
+    it 'should create database' do
+      subject.create_database("datomic:mem://#{@db_name}").should be_true
+    end
+
+    context Diametric::Persistence::Peer do
+      it 'should connect to the database' do
+        subject.connect("datomic:mem://#{@db_name}").should be_true
+      end
+
+      it 'should get tempid' do
+        subject.tempid(":db.part/db").to_s.should match(/#db\/id\[:db.part\/db\s-\d+\]/)
+        subject.tempid(":db.part/user").to_s.should match(/#db\/id\[:db.part\/user\s-\d+\]/)
+        subject.tempid(":db.part/user", -1).to_s.should match(/#db\/id\[:db.part\/user\s-1\]/)
+      end
+
+      it "should return uuid from squuid" do
+        re = Regexp.new(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/)
+        subject.squuid.to_s.should match(re)
+      end
+
+      it "should return Fixnum from squuid_time_millis" do
+        du = Diametric::Persistence::UUID.new
+        subject.squuid_time_millis(du).class.should == Fixnum
+      end
+    end
+
+    context Diametric::Persistence::Connection do
+      @db_name = "test-#{SecureRandom.uuid}"
+      let(:connection) { Diametric::Persistence::Peer.connect("datomic:mem://#{@db_name}") }
+      let(:tempid) { Diametric::Persistence::Peer.tempid(":db.part/db") }
+      let(:tx_data) {
+        [{
+           ":db/id" => tempid,
+           ":db/ident" => ":person/name",
+           ":db/valueType" => ":db.type/string",
+           ":db/cardinality" => ":db.cardinality/one",
+           ":db/doc" => "A person's name",
+           ":db.install/_attribute" => ":db.part/db"
+         }]
+      }
+      let(:user_data) {
+        [{":db/id" => user_part_tempid, ":person/name" => "Alice"},
+         {":db/id" => user_part_tempid, ":person/name" => "Bob"},
+         {":db/id" => user_part_tempid, ":person/name" => "Chris"}]
+      }
+
+      it 'should transact schema' do
+        connection.transact(tx_data).class.should == Diametric::Persistence::ListenableFuture
+      end
+
+      it 'should get future object for schema' do
+        connection.transact(tx_data).get.should be_true
+      end
+
+      it 'should transact data' do
+        connection.transact(tx_data).get
+        connection.transact(user_data).get.should be_true
+      end
+
+      it 'should resolve tempid' do
+        tmp_tempid = user_part_tempid
+        connection.transact(tx_data).get
+        map = connection.transact([{":db/id" => tmp_tempid, ":person/name" => "Alice"}]).get
+        resolved_tempid = Diametric::Persistence::Peer.resolve_tempid(map,  tmp_tempid)
+        resolved_tempid.should be_true
+        resolved_tempid.to_s.should match(/\d+/)
+        #puts "resolved_tempid: #{resolved_tempid}"
+      end
+    end
+
+    context 'Diametric query' do
+      before do
+        tx_data =
+          [{
+             ":db/id" => Diametric::Persistence::Peer.tempid(":db.part/db"),
+             ":db/ident" => ":person/name",
+             ":db/valueType" => ":db.type/string",
+             ":db/cardinality" => ":db.cardinality/one",
+             ":db/doc" => "A person's name",
+             ":db.install/_attribute" => ":db.part/db"
+           }]
+        user_data = 
+          [{":db/id" => Diametric::Persistence::Peer.tempid(":db.part/user"), ":person/name" => "Alice"},
+           {":db/id" => Diametric::Persistence::Peer.tempid(":db.part/user"), ":person/name" => "Bob"},
+           {":db/id" => Diametric::Persistence::Peer.tempid(":db.part/user"), ":person/name" => "Chris"}]
+        @db_name = "test-#{SecureRandom.uuid}"
+        @connection = Diametric::Persistence::Peer.connect("datomic:mem://#{@db_name}")
+
+        @connection.transact(tx_data).get
+        @connection.transact(user_data).get
+      end
+
+      it 'should get ids from datomic' do
+        results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]", @connection.db)
+        results.class.should == Array
+        results.size.should be >= 3
+        #puts results.inspect
+      end
+
+      it 'should get names from datomic' do
+        results = Diametric::Persistence::Peer.q("[:find ?c ?name :where [?c :person/name ?name]]\
+  ", @connection.db)
+        results.flatten.should include("Alice")
+        results.flatten.should include("Bob")
+        results.flatten.should include("Chris")
+        #puts results.inspect
+      end
+
+      it 'should get entity by id' do
+        results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]",\
+                                                 @connection.db)
+        id = results[0][0]
+        @connection.db.entity(id).should be_true
+      end
+
+      it 'should get keys from entity id' do
+        results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]",\
+                                                 @connection.db)
+        id = results[0][0]
+        entity = @connection.db.entity(id)
+        entity.keys.should include(":person/name")
+        #puts entity.keys
+      end
+
+      it 'should get value from entity id' do
+        results = Diametric::Persistence::Peer.q("[:find ?c :where [?c :person/name]]",\
+                                                 @connection.db)
+        id = results[0][0]
+        entity = @connection.db.entity(id)
+        value =  entity.get(entity.keys[0])
+        value.should match(/Alice|Bob|Chris/)
+        #puts value
+      end
+    end
+  end
+end
+
+def user_part_tempid
+  Diametric::Persistence::Peer.tempid(":db.part/user")
+end