diametric 0.1.1-java

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

data/spec/diametric/persistence/peer_many2many_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'diametric/persistence/peer'
+require 'securerandom'
+
+describe Diametric::Persistence::Peer, :jruby do
+  before do
+    db_uri = "datomic:mem://hello-#{SecureRandom.uuid}"
+    @conn = subject.connect(:uri => db_uri)
+    Author.create_schema(@conn)
+    Book.create_schema(@conn)
+  end
+  after do
+    @conn.release
+  end
+
+  it "should save one in caridinality many associations" do
+    author = Author.new(:name => "wilber", :books => [])
+    author.save
+    book = Book.new(:title => "Candy", :authors => [])
+    book.save
+    author.update(:books => [book])
+    result = Diametric::Persistence::Peer.q("[:find ?e ?name ?books :in $ :where [?e :author/name ?name] [?e :author/books ?books]]", @conn.db)
+    boo_dbid = result.first[2]
+    boo = Author.from_dbid_or_entity(boo_dbid, @conn)
+    boo.title.should == "Candy"
+  end
+
+  it "should save two in caridinality many associations" do
+    author = Author.new(:name => "wilber", :books => [])
+    author.save
+    book1 = Book.new(:title => "Honey", :authors => [])
+    book1.save
+    book2 = Book.new(:title => "Chips", :authors => [])
+    book2.save
+    author.update(:books => [book1, book2])
+    result = Diametric::Persistence::Peer.q("[:find ?e ?name ?books :in $ :where [?e :author/name ?name] [?e :author/books ?books]]", @conn.db)
+    result.size.should == 2
+    boo_dbid = result[0][2]
+    boo = Book.from_dbid_or_entity(boo_dbid, @conn)
+    boo.title.should match(/Honey|Chips/)
+    foo_dbid = result[1][2]
+    foo = Book.from_dbid_or_entity(boo_dbid, @conn)
+    foo.title.should match(/Honey|Chips/)
+  end
+
+  it "should save two in caridinality many associations" do
+    author1 = Author.new(:name => "Ms. Wilber", :books => [])
+    author1.save
+    author2 = Author.new(:name => "Mr. Smith", :books => [])
+    author2.save
+    book1 = Book.new(:title => "Pie", :authors => [])
+    book1.save
+    book2 = Book.new(:title => "Donuts", :authors => [])
+    book2.save
+    author1.update(:books => [book1, book2])
+    book1.update(:authors => [author1, author2])
+
+    result = Diametric::Persistence::Peer.q("[:find ?e :in $ [?name] :where [?e :author/name ?name]]", @conn.db, ["Ms. Wilber"])
+    result.size.should == 1
+    result.first.first.to_s.should == author1.dbid.to_s
+    a = Author.from_dbid_or_entity(result.first.first, @conn)
+    a.books.size.should == 2
+    a.books.each do |b|
+      Author.from_dbid_or_entity(b, @conn).title.should match(/Pie|Donuts/)
+    end
+
+    result = Diametric::Persistence::Peer.q("[:find ?e :in $ [?title] :where [?e :book/title ?title]]", @conn.db, ["Pie"])
+    result.size.should == 1
+    result.first.first.to_s.should == book1.dbid.to_s
+    b = Book.from_dbid_or_entity(result.first.first, @conn)
+    b.authors.size.should == 2
+    b.authors.each do |a|
+      Book.from_dbid_or_entity(a, @conn).name.should match(/Ms\.\sWilber|Mr\.\sSmith/)
+    end
+  end
+end

data/spec/diametric/persistence/peer_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'diametric/persistence/peer'
+require 'securerandom'
+
+describe Diametric::Persistence::Peer, :jruby do
+  before do
+    @db_uri = "datomic:mem://hello-#{SecureRandom.uuid}"
+  end
+
+  it "can connect to a Datomic database" do
+    connection = subject.connect(:uri => @db_uri)
+    connection.should be_a(Diametric::Persistence::Connection)
+  end
+
+  it_behaves_like "persistence API" do
+    let(:model_class) { Rat }
+
+    before do
+      @connection = Diametric::Persistence::Peer.connect(:uri => @db_uri)
+      Diametric::Persistence::Peer.create_schemas(@connection)
+    end
+
+    after do
+      @connection.release
+    end
+  end
+end

data/spec/diametric/persistence/rest_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'diametric/persistence/rest'
+require 'securerandom'
+
+describe Diametric::Persistence::REST, :integration do
+  before do
+    @db_uri = ENV['DATOMIC_URI'] || 'http://localhost:46291'
+    @storage = ENV['DATOMIC_STORAGE'] || 'free'
+    @dbname = ENV['DATOMIC_NAME'] || "test-#{SecureRandom.uuid}"
+    @connection_options = {
+      :uri => @db_uri,
+      :storage => @storage,
+      :database => @dbname
+    }
+  end
+
+  it "can connect to a Datomic database" do
+    subject.connect(@connection_options)
+    subject.connection.should be_a(Datomic::Client)
+  end
+
+  it_behaves_like "persistence API" do
+    let(:model_class) { Mouse }
+
+    before do
+      Diametric::Persistence::REST.connect(@connection_options)
+      Diametric::Persistence::REST.create_schemas
+    end
+  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

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Diametric::Query do
+  let(:query) { Diametric::Query.new(Goat) }
+
+  describe "#where" do
+    it "is non-destructive" do
+      query.where(:age => 2)
+      query.conditions.should be_empty
+    end
+
+    it "raises when non-searchable conditions (id?) are passed"
+  end
+
+  describe "#filter" do
+    it "is non-destructive" do
+      query.filter(:<, :age, 2)
+      query.filters.should be_empty
+    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"]], nil, true)
+      Diametric::Query.new(model, nil, true).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, nil, true) }
+
+    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, nil, true).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
+      query.data.should == [
+        [
+          :find, ~"?e", ~"?name", ~"?birthday",
+          :in, ~"\$",
+          :where,
+          [~"?e", :"goat/name", ~"?name"],
+          [~"?e", :"goat/birthday", ~"?birthday"]
+        ],
+        []
+      ]
+    end
+
+    it "should generate a query given a condition" do
+      query.where(:name => "Beans").data.should == [
+        [
+          :find, ~"?e", ~"?name", ~"?birthday",
+          :in, ~"\$", ~"?name",
+          :where,
+          [~"?e", :"goat/name", ~"?name"],
+          [~"?e", :"goat/birthday", ~"?birthday"]
+        ],
+        ["Beans"]
+      ]
+    end
+
+    it "should generate a query given multiple conditions" do
+      bday = DateTime.parse("2003-09-04 11:30 AM")
+
+      query.where(:name => "Beans", :birthday => bday).data.should == [
+        [
+          :find, ~"?e", ~"?name", ~"?birthday",
+          :in, ~"\$", ~"?name", ~"?birthday",
+          :where,
+          [~"?e", :"goat/name", ~"?name"],
+          [~"?e", :"goat/birthday", ~"?birthday"]
+        ],
+        ["Beans", bday]
+      ]
+    end
+  end
+end