diametric 0.0.4 → 0.1.1

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

@@ -1,36 +1,27 @@
 require 'spec_helper'
-require 'diametric/persistence/peer' if RUBY_ENGINE == 'jruby'
-
-# Prevent CRuby from blowing up
-module Diametric
-  module Persistence
-    module Peer
-    end
-  end
-end
+require 'diametric/persistence/peer'
+require 'securerandom'
 
 describe Diametric::Persistence::Peer, :jruby do
-  class Rat
-    include Diametric::Entity
-    include Diametric::Persistence::Peer
-
-    attribute :name, String, :index => true
-    attribute :age, Integer
+  before do
+    @db_uri = "datomic:mem://hello-#{SecureRandom.uuid}"
   end
 
-  let(:db_uri) { 'datomic:mem://hello' }
-
   it "can connect to a Datomic database" do
-    subject.connect(:uri => db_uri)
-    subject.connection.should be_a(Java::DatomicPeer::LocalConnection)
+    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(:all) do
-      subject.connect(:uri => db_uri)
-      Diametric::Persistence::Peer.create_schemas
+    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

@@ -1,36 +1,29 @@
 require 'spec_helper'
 require 'diametric/persistence/rest'
+require 'securerandom'
 
 describe Diametric::Persistence::REST, :integration do
-  class Mouse
-    include Diametric::Entity
-    include Diametric::Persistence::REST
-
-    attribute :name, String, :index => true
-    attribute :age, Integer
-  end
-
-  let(:connection_options) do
-    {
-      :uri => db_uri,
-      :storage => storage,
-      :database => dbname
+  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
-  let(:db_uri) { ENV['DATOMIC_URI'] || 'http://localhost:9000' }
-  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(connection_options)
+    subject.connect(@connection_options)
     subject.connection.should be_a(Datomic::Client)
   end
 
   it_behaves_like "persistence API" do
     let(:model_class) { Mouse }
 
-    before(:all) do
-      subject.connect(connection_options)
+    before do
+      Diametric::Persistence::REST.connect(@connection_options)
       Diametric::Persistence::REST.create_schemas
     end
   end

data/spec/diametric/query_spec.rb

@@ -26,9 +26,8 @@ describe Diametric::Query do
         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}
+      model.should_receive(:from_query).with([1, "Stu", ["chocolate", "vanilla"]], nil, true)
+      Diametric::Query.new(model, nil, true).each {|x| x}
     end
   end
 
@@ -39,7 +38,7 @@ describe Diametric::Query do
         attribute :likes, String, :cardinality => :many
       end
     end
-    let(:query) { Diametric::Query.new(model) }
+    let(:query) { Diametric::Query.new(model, nil, true) }
 
     context "with multiple results per entity" do
       it "collapses cardinality/many attributes into lists" do
@@ -65,7 +64,7 @@ describe Diametric::Query do
         attribute :likes, String, :cardinality => :many
       end
       model.stub(:q => [[1, "Stu", "chocolate"], [1, "Stu", "vanilla"]])
-      Diametric::Query.new(model).all.each do |e|
+      Diametric::Query.new(model, nil, true).all.each do |e|
         e.name.should == "Stu"
         e.likes.class.should == Set
         e.likes.should include "chocolate"

data/spec/diametric/rest_service_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'net/http'
+
+describe Diametric::RestService, :service =>true do
+  let(:service) { Diametric::RestService }
+
+  before do
+    dir = File.join(File.dirname(__FILE__), "../..", "tmp/datomic")
+    FileUtils.rm_rf(dir)
+    FileUtils.mkdir_p(dir)
+  end
+
+  it "should find a class" do
+    service.should be_true
+  end
+
+  it "should find a default conf file" do
+    service.datomic_conf_file?.should be_true
+  end
+
+  it "should find a specified conf file" do
+    service.datomic_conf_file?("spec/test_version_file.yml").should be_true
+  end
+
+  it "should return false for version no" do
+    service.datomic_conf_file?("datomic-free-0.8.4122").should be_false
+  end
+
+  it "should know datomic version specified" do
+    service.datomic_version("spec/test_version_file.yml").should == "datomic-free-0.8.4122"
+    service.datomic_version("datomic-free-0.8.4122").should == "datomic-free-0.8.4122"
+  end
+
+  it  "should know the specified version of datomic has been downloaded" do
+    service.downloaded?("spec/test_version_file.yml", "tmp/datomic").should be_false
+    service.downloaded?("datomic-free-0.8.4122", "tmp/datomic").should be_false
+
+    service.download("spec/test_version_file.yml", "tmp/datomic")
+  
+    service.downloaded?("spec/test_version_file.yml", "tmp/datomic").should be_true
+    service.downloaded?("datomic-free-0.8.4122", "tmp/datomic").should be_true
+  end
+
+  context Diametric::RestService do
+    let(:rest) { Diametric::RestService.new("spec/test_version_file.yml", "tmp/datomic") }
+    
+    it "should start and stop rest service" do
+      uri = URI("http://localhost:49621")
+      expect { Net::HTTP.get_response(uri) }.to raise_error
+      rest.start(:port => 49621, :db_alias => "free", :uri => "datomic:mem://")
+      expect { Net::HTTP.get_response(uri) }.not_to raise_error
+      rest.stop
+      expect { Net::HTTP.get_response(uri) }.to raise_error
+    end
+  end
+end

data/spec/diametric/transactor_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'net/http'
+
+describe "Transactor Service", :transactor =>true do
+  let(:transactor) { Diametric::Transactor }
+
+  before do
+    dir = File.join(File.dirname(__FILE__), "../..", "tmp/datomic")
+    FileUtils.rm_rf(dir)
+    FileUtils.mkdir_p(dir)
+  end
+
+  it "should find a class" do
+    transactor.should be_true
+  end
+
+  it "should find a default conf file" do
+    transactor.datomic_conf_file?.should be_true
+  end
+
+  it "should find a specified conf file" do
+    transactor.datomic_conf_file?("spec/test_version_file.yml").should be_true
+  end
+
+  it "should return false for version no" do
+    transactor.datomic_conf_file?("datomic-free-0.8.4122").should be_false
+  end
+
+  it "should know datomic version specified" do
+    transactor.datomic_version("spec/test_version_file.yml").should == "datomic-free-0.8.4122"
+    transactor.datomic_version("datomic-free-0.8.4122").should == "datomic-free-0.8.4122"
+  end
+
+  it  "should know the specified version of datomic has been downloaded" do
+    transactor.downloaded?("spec/test_version_file.yml", "tmp/datomic").should be_false
+    transactor.downloaded?("datomic-free-0.8.4122", "tmp/datomic").should be_false
+
+    transactor.download("spec/test_version_file.yml", "tmp/datomic")
+  
+    transactor.downloaded?("spec/test_version_file.yml", "tmp/datomic").should be_true
+    transactor.downloaded?("datomic-free-0.8.4122", "tmp/datomic").should be_true
+  end
+
+  context Diametric::Transactor do
+    let(:transactor) { Diametric::Transactor.new("spec/test_version_file.yml", "tmp/datomic") }
+    
+    it "should start and stop transactor" do
+      filename = File.join(File.dirname(__FILE__), "..", "config", "free-transactor-template.properties")
+      File.exists?(filename).should be_true
+      transactor.start(filename).should be_true
+      transactor.stop
+    end
+  end
+
+  context Diametric::Transactor do
+    let(:transactor) { Diametric::Transactor.new("spec/test_version_file.yml", "tmp/datomic") }
+
+    it "should be available to create_database and connect to" do
+      filename = File.join(File.dirname(__FILE__), "..", "config", "free-transactor-template.properties")
+      transactor.start(filename).should be_true
+      uri = "datomic:free://localhost:39082/transactor-#{SecureRandom.uuid}"
+      Diametric::Persistence::Peer.create_database(uri).should be_true
+      Diametric::Persistence::Peer.connect(uri).should be_true
+      transactor.stop
+    end
+  end
+
+end

data/spec/integration_spec.rb

@@ -1,14 +1,16 @@
 require 'spec_helper'
+require 'diametric/entity'
 require 'datomic/client'
+require 'securerandom'
 
 # Datomic's `rest` needs to run for these tests to pass:
 #   bin/rest 9000 test datomic:mem://
 
 describe Diametric::Entity, :integration => true do
   before(:all) do
-    @datomic_uri = ENV['DATOMIC_URI'] || 'http://localhost:9000'
+    @datomic_uri = ENV['DATOMIC_URI'] || 'http://localhost:46291'
     @storage = ENV['DATOMIC_STORAGE'] || 'free'
-    @dbname = ENV['DATOMIC_NAME'] || "test-#{Time.now.to_i}"
+    @dbname = ENV['DATOMIC_NAME'] || "test-#{SecureRandom.uuid}"
     @client = Datomic::Client.new @datomic_uri, @storage
     @client.create_database(@dbname)
     sleep 0.5
@@ -77,7 +79,7 @@ describe Diametric::Entity, :integration => true do
       robin.save.should be_false
       robin.name = "Mary"
       robin.age = 3
-      expect { robin.save! }.to_not raise_error(Diametric::Errors::ValidationError)
+      expect { robin.save! }.not_to raise_error()
       robin.persisted?.should be_true
     end
     it "can update entity" do

data/spec/parent_child_sample.rb

@@ -0,0 +1,42 @@
+require 'conf_helper'
+
+class Somebody
+  include Diametric::Entity
+  include Diametric::Persistence::Peer
+
+  attribute :name, String
+  attribute :parent, Ref, :cardinality => :one
+end
+
+describe "RailsConf 2013", :jruby => true do
+  context Somebody do
+    before(:all) do
+      datomic_uri = "datomic:mem://somebody-#{SecureRandom.uuid}"
+      @conn = Diametric::Persistence::Peer.connect(datomic_uri)
+    end
+    after(:all) do
+      @conn.release
+    end
+
+    it "should create schema" do
+      binding.pry
+      Sombody.create_schema(@conn)
+    end
+
+    it "should create instances" do
+      alice = Somebody.new
+      alice.name = "Alice Wonderland"
+      alice.parent = ""
+      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/peer_integration_spec.rb

@@ -1,37 +1,121 @@
 require 'spec_helper'
+require 'diametric/entity'
 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
+  context Penguin do
+    before(:all) do
+      @datomic_uri = ENV['DATOMIC_URI'] || 'datomic:mem://animals'
+      @conn = Diametric::Persistence.establish_base_connection({:uri => @datomic_uri})
+      Penguin.create_schema(@conn)
+    end
+
+    after(:all) do
+      @conn.release
+    end
+
+    let(:query) { Diametric::Query.new(Penguin, @conn, true) }
+    it "should update entity" do
+      penguin = Penguin.new(:name => "Mary", :age => 2)
+      penguin.save(@conn)
+      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(@conn)
+      number_of_penguins = Penguin.all.size
+      number_of_penguins.should >= 1
+      penguin.destroy
+      Penguin.all.size.should == (number_of_penguins -1)
+    end
   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
+  context Choice do
+    before(:all) do
+      @datomic_uri = ENV['DATOMIC_URI'] || 'datomic:mem://choices'
+      @conn2 = Diametric::Persistence.establish_base_connection({:uri => @datomic_uri})
+      Choice.create_schema(@conn2)
+    end
+
+    after(:all) do
+      @conn2.release
+    end
+
+    it "should save entity" do
+      choice = Choice.new(:item => "Boots", :checked => true)
+      choice.save.should_not be_nil
+      result = Diametric::Persistence::Peer.q("[:find ?e :in $ :where [?e :choice/checked]]", @conn2.db)
+      choice = Choice.from_dbid_or_entity(result.first.first, @conn2.db)
+      choice.checked.should be_true
+    end
   end
 
-  it "should search upadated attributes" do
-    penguin = query.where(:name => "Mary").first
-    penguin.name.should == "Mary"
-    penguin.age.should == 3
+  context Customer do
+    before(:all) do
+      @datomic_uri = ENV['DATOMIC_URI'] || 'datomic:mem://choices'
+      @conn3 = Diametric::Persistence.establish_base_connection({:uri => @datomic_uri})
+      Customer.create_schema(@conn3)
+    end
+
+    after(:all) do
+      @conn3.release
+    end
+
+    it "should save entity with Diametric uuid" do
+      id = Diametric::Persistence::Peer.squuid
+      customer = Customer.new(:name => "John Smith", :id => id)
+      customer.save.should_not be_nil
+      result = Diametric::Persistence::Peer.q("[:find ?e :in $ :where [?e :customer/name]]", @conn3.db)
+      customer2 = Customer.from_dbid_or_entity(result.first.first, @conn3.db)
+      customer2.name.should == "John Smith"
+      customer2.id.to_s.should == id.to_s
+    end
+
+    it "should save entity with Ruby uuid" do
+      require 'uuid'
+      id = UUID.new.generate
+      customer = Customer.new(:name => "Wilber Hoe", :id => id)
+      customer.save.should_not be_nil
+      result = Diametric::Persistence::Peer.q("[:find ?e :in $ [?name] :where [?e :customer/name ?name]]", @conn3.db, ["Wilber Hoe"])
+      customer2 = Customer.from_dbid_or_entity(result.first.first, @conn3.db)
+      customer2.name.should == "Wilber Hoe"
+      customer2.id.to_s.should == id.to_s
+    end
   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)
+  context Account do
+    before(:all) do
+      @datomic_uri = ENV['DATOMIC_URI'] || 'datomic:mem://account'
+      @conn4 = Diametric::Persistence.establish_base_connection({:uri => @datomic_uri})
+      Account.create_schema(@conn4)
+    end
+
+    after(:all) do
+      @conn4.release
+    end
+
+    it "should save entity" do
+      account = Account.new(:name => "This month's deposits", :deposit => [100.0, 200.0], :amount => 0.0)
+      account.save.should_not be_nil
+      result = Diametric::Persistence::Peer.q("[:find ?e :in $ :where [?e :account/name]]", @conn4.db)
+      account2 = Customer.from_dbid_or_entity(result.first.first, @conn4.db)
+      account2.name.should == account.name
+      account2.amount.should == 0.0
+      account2.deposit.should include(100.0)
+      account2.deposit.should include(200.0)
+    end
+
   end
 end