diametric 0.1.1-java

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

@@ -0,0 +1,107 @@
+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:46291'
+    @storage = ENV['DATOMIC_STORAGE'] || 'free'
+    @dbname = ENV['DATOMIC_NAME'] || "test-#{SecureRandom.uuid}"
+    @client = Datomic::Client.new @datomic_uri, @storage
+    @client.create_database(@dbname)
+    sleep 0.5
+  end
+
+  it "can load the schema" do
+    resp = @client.transact(@dbname, Person.schema)
+    resp.code.should == 201
+    resp.data.should be_a(Hash)
+    resp.data.keys.sort.should == [:"db-after", :"db-before", :tempids, :"tx-data"]
+  end
+
+  describe "with a schema" do
+    before(:all) do
+      @client.transact(@dbname, Person.schema)
+      @client.transact(@dbname, Goat.schema)
+    end
+
+    it "can transact an entity" do
+      birthday = DateTime.parse("1976-09-04")
+      goat = Goat.new(:name => "Beans", :birthday => birthday)
+      resp = @client.transact(@dbname, goat.tx_data)
+      resp.code.should == 201
+      resp.data.should be_a(Hash)
+      resp.data.keys.sort.should == [:"db-after", :"db-before", :tempids, :"tx-data"]
+    end
+  end
+
+  describe "with an entity" do
+    before(:all) do
+      goat = Goat.new(:name => "Josef", :birthday => DateTime.parse("1976-09-04"))
+      @client.transact(@dbname, goat.tx_data)
+    end
+
+    it "can query for that entity" do
+      query, args = Diametric::Query.new(Goat).where(:name => "Josef").data
+      args = args.unshift({:"db/alias" => "#{@storage}/#{@dbname}"})
+      resp = @client.query(query, args)
+      resp.code.should == 200
+      resp.data.should be_a(Array)
+      resp.data.count.should == 1
+      resp.data.first.count.should == 3
+    end
+
+    it "can rehydrate an entity from a query" do
+      query, args = Diametric::Query.new(Goat).where(:name => "Josef").data
+      args = args.unshift({:"db/alias" => "#{@storage}/#{@dbname}"})
+      resp = @client.query(query, args)
+      resp.code.should == 200
+
+      goats = resp.data.map { |data| Goat.from_query(data) }
+      goats.first.name.should == "Josef"
+    end
+  end
+
+  describe "with persistence module" do
+    before(:all) do
+      Robin.create_schema
+    end
+
+    let(:query) { Diametric::Query.new(Robin) }
+    it "can create entity" do
+      robin = Robin.new
+      
+      expect { robin.save! }.to raise_error(Diametric::Errors::ValidationError)
+      robin.save.should be_false
+      robin.name = "Mary"
+      robin.age = 3
+      expect { robin.save! }.not_to raise_error()
+      robin.persisted?.should be_true
+    end
+    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/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

@@ -0,0 +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
+  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
+
+  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
+
+  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
+
+  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

data/spec/peer_seattle_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+require 'diametric/entity'
+require 'datomic/client'
+
+describe Diametric::Entity, :integration => true, :jruby => true do
+  context District do
+    before(:all) do
+      datomic_uri = "datomic:mem://district-#{SecureRandom.uuid}"
+      @d_conn1 = Diametric::Persistence::Peer.connect(datomic_uri)
+    end
+    after(:all) do
+      @d_conn1.release
+    end
+    let(:district) { District.create_schema(@d_conn1) }
+    it "should create schema" do
+      district.should_not be_nil
+    end
+    it "should return future object" do
+      district.should be_a(Diametric::Persistence::ListenableFuture)
+    end
+    it "should return object by get from future do" do
+      district.get.should_not be_nil
+    end
+  end
+
+  context District do
+    before(:all) do
+      datomic_uri = "datomic:mem://district-#{SecureRandom.uuid}"
+      @d_conn2 = Diametric::Persistence::Peer.connect(datomic_uri)
+      District.create_schema(@d_conn2).get
+    end
+    after(:all) do
+      @d_conn2.release
+    end
+    it "should save instance" do
+      district = District.new
+      district.name = "East"
+      district.region = District::Region::E
+      district.save(@d_conn2).should_not be_nil
+      district.tx_data.should be_empty
+    end
+    it "should get instance" do
+      query = Diametric::Query.new(District, @d_conn2, true)
+      district = query.where(:name => "East").first
+      district.name.should == "East"
+      district.region.should == District::Region::E
+    end
+  end
+
+  context Neighborhood do
+    before(:all) do
+      datomic_uri = "datomic:mem://neighborhood-#{SecureRandom.uuid}"
+      @n_conn1 = Diametric::Persistence::Peer.connect(datomic_uri)
+    end
+    after(:all) do
+      @n_conn1.release
+    end
+    it "should create schema" do
+      Neighborhood.create_schema(@n_conn1).get.should_not be_nil
+    end
+  end
+
+  context Neighborhood do
+    before(:all) do
+      datomic_uri = "datomic:mem://neighborhood-#{SecureRandom.uuid}"
+      @n_conn2 = Diametric::Persistence::Peer.connect(datomic_uri)
+      Neighborhood.create_schema(@n_conn2).get
+      District.create_schema(@n_conn2).get
+    end
+    after(:all) do
+      @n_conn2.release
+    end
+
+    it "should save instance" do
+      district = District.new
+      district.name = "East"
+      district.region = District::Region::E
+      neighborhood = Neighborhood.new
+      neighborhood.name = "Capitol Hill"
+      neighborhood.district = district
+      neighborhood.save(@n_conn2).should_not be_nil
+      district.tx_data.should be_empty
+      neighborhood.tx_data.should be_empty
+    end
+
+    it "should not include tx_data of saved entity" do
+      district = District.new
+      district.name = "Southwest"
+      district.region = District::Region::SW
+      district.save(@n_conn2)
+      neighborhood = Neighborhood.new
+      neighborhood.name = "Admiral (West Seattle)"
+      neighborhood.district = district
+
+      result = []
+      neighborhood.parse_tx_data(neighborhood.tx_data, result)
+      result.first[":neighborhood/district"].to_s.should match(/^\d+/)
+
+      neighborhood.save(@n_conn2)
+      district.tx_data.should be_empty
+      neighborhood.tx_data.should be_empty
+    end
+
+    it "should get instance" do
+      district = District.new
+      district.name = "East"
+      district.region = District::Region::E
+      neighborhood = Neighborhood.new
+      neighborhood.name = "Capitol Hill"
+      neighborhood.district = district
+      neighborhood.save(@n_conn2).should_not be_nil
+
+      query = Diametric::Query.new(Neighborhood, @n_conn2, true)
+      neighborhood = query.where(:name => "Capitol Hill").first
+      neighborhood.dbid.should_not be_nil
+      neighborhood.name.should == "Capitol Hill"
+      neighborhood.district.should be_a(District)
+      neighborhood.district.dbid.should_not be_nil
+      neighborhood.district.name.should == "East"
+      neighborhood.district.region.should == District::Region::E
+    end
+
+    it "should not resolve ref type dbid" do
+      district = District.new
+      district.name = "East"
+      district.region = District::Region::E
+      neighborhood = Neighborhood.new
+      neighborhood.name = "Capitol Hill"
+      neighborhood.district = district
+      neighborhood.save(@n_conn2).should_not be_nil
+
+      query = Diametric::Query.new(Neighborhood, @n_conn2, true)
+      neighborhood = query.where(:name => "Capitol Hill").first
+      neighborhood.name.should == "Capitol Hill"
+      neighborhood.district.should be_a(District)
+    end
+  end
+
+  context Community do
+    before(:all) do
+      datomic_uri = "datomic:mem://community-#{SecureRandom.uuid}"
+      @s_conn1 = Diametric::Persistence::Peer.connect(datomic_uri)
+    end
+    after(:all) do
+      @s_conn1.release
+    end
+    it "should create schema" do
+      Community.create_schema(@s_conn1).get.should_not be_nil
+    end
+  end
+
+  context Community do
+    before(:all) do
+      datomic_uri = "datomic:mem://community-#{SecureRandom.uuid}"
+      @s_conn2 = Diametric::Persistence::Peer.connect(datomic_uri)
+      Neighborhood.create_schema(@s_conn2).get
+      District.create_schema(@s_conn2).get
+      Community.create_schema(@s_conn2).get
+    end
+    after(:all) do
+      @s_conn2.release
+    end
+
+    it "should save instance" do
+      district = District.new
+      district.name = "East"
+      district.region = District::Region::E
+      neighborhood = Neighborhood.new
+      neighborhood.name = "Capitol Hill"
+      neighborhood.district = district
+      community = Community.new
+      community.name = "15th Ave Community"
+      community.url = "http://groups.yahoo.com/group/15thAve_Community/"
+      community.neighborhood = neighborhood
+      community.category = ["15th avenue residents"]
+      community.orgtype = Community::Orgtype::COMMUNITY
+      community.type = Community::Type::EMAIL_LIST
+      community.save(@n_conn2).should_not be_nil
+    end
+
+    it "should get instance" do
+      query = Diametric::Query.new(Community, @s_conn2, true)
+      community = query.where(:name => "15th Ave Community").first
+      community.dbid.should_not be_nil
+      community.name.should == "15th Ave Community"
+      community.url.should == "http://groups.yahoo.com/group/15thAve_Community/"
+      community.neighborhood.should be_a(Neighborhood)
+      community.neighborhood.dbid.should_not be_nil
+      community.neighborhood.name.should == "Capitol Hill"
+      community.neighborhood.district.should be_a(District)
+      community.neighborhood.district.dbid.should_not be_nil
+      community.neighborhood.district.name.should == "East"
+      community.neighborhood.district.region.should == District::Region::E
+      community.category == ["15th avenue residents"]
+      community.orgtype.should == Community::Orgtype::COMMUNITY
+      community.type.should == Community::Type::EMAIL_LIST
+    end
+  end
+
+end