rhoconnect 4.0.4 → 5.1.1

data/spec/document_spec.rb

@@ -1,69 +1,69 @@
 require File.join(File.dirname(__FILE__),'spec_helper')
 
 describe "Document" do
-  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
-    before(:each) do
-      @valid_docs = [:foo1, :foo, :key, :key1, :key2]
-      Client.define_valid_doctypes(@valid_docs)
-      @s = Source.load(@s_fields[:name],@s_params)
-    end
+  include_examples "SharedRhoconnectHelper", :rhoconnect_data => true
 
-    after(:each) do
-      @valid_docs.each do |doctype|
-        Client.valid_doctypes.delete(doctype)
-      end
-    end
-    
-    it "should generate client docname" do
-      @c.docname(:foo).should == "client:#{@a.id}:#{@u.id}:#{@c.id}:#{@s_fields[:name]}:foo"
-    end
+  before(:each) do
+    @valid_docs = [:foo1, :foo, :key, :key1, :key2]
+    Client.define_valid_doctypes(@valid_docs)
+    @s = Source.load(@s_fields[:name],@s_params)
+  end
 
-    it "should generate InvalidDocumentException for invalid client doctype" do
-      lambda { @c.put_data(:foo_invalid,{'1'=>@product1}) }.should raise_error(InvalidDocumentException, "Invalid document type foo_invalid for Rhoconnect::Client")
-      store_index = @c.store_index(:foo_invalid)
-      Store.get_store(store_index).db.keys(@c.docname('*')).should == []
+  after(:each) do
+    @valid_docs.each do |doctype|
+      Client.valid_doctypes.delete(doctype)
     end
+  end
 
-    it "should generate source docname" do
-      @s.docname(:foo).should == "source:#{@a.id}:#{@u.id}:#{@s_fields[:name]}:foo"
-    end
+  it "should generate client docname" do
+    @c.docname(:foo).should == "client:#{@a.id}:#{@u.id}:#{@c.id}:#{@s_fields[:name]}:foo"
+  end
 
-    it "should flush_data for docname" do
-      @c.put_data(:foo1,{'1'=>@product1})
-      docname = @c.docname(:foo1)
-      bucket_index = get_sha1('1')[0..1]
-      store_index = @c.store_index(:foo1)
-      Store.get_store(store_index).db.keys(@c.docname('*')).sort.should == ["#{docname}:#{bucket_index}", "#{docname}:indices"].sort
-      @c.flush_all_documents
-      Store.get_store(store_index).db.keys(@c.docname('*')).should == []
-    end
-    
-    it "should flush_data for arrays" do
-      @c.put_list(:foo1,['1', '2', '3'])
-      @c.exists?(:foo1).should == true
-      @c.flush_all_documents
-      @c.exists?(:foo1).should == false
-    end
-    
-    it "should get_data for arrays" do
-      @c.put_list(:foo1,['1', '2', '3'])
-      @c.get_data(:foo1, Array).should == ['1', '2', '3']
-      JSON.parse(@c.get_db_doc(:foo1)).should == ['1', '2', '3']
-    end
+  it "should generate InvalidDocumentException for invalid client doctype" do
+    lambda { @c.put_data(:foo_invalid,{'1'=>@product1}) }.should raise_error(InvalidDocumentException, "Invalid document type foo_invalid for Rhoconnect::Client")
+    store_index = @c.store_index(:foo_invalid)
+    Store.get_store(store_index).db.keys(@c.docname('*')).should == []
+  end
 
-    it "should rename doc" do
-      @c.put_data(:key1, @data)
-      @c.rename(:key1,:key2)
-      @c.exists?(:key1).should == false
-      @c.get_data(:key2).should == @data
-    end
-    
-    it "should operate with individual object" do
-      key = '1'
-      data = {'foo' => 'bar'}
-      @c.put_object(:cd, key, data)
-      obj = @c.get_object(:cd, key)
-      obj.should == data
-    end
+  it "should generate source docname" do
+    @s.docname(:foo).should == "source:#{@a.id}:#{@u.id}:#{@s_fields[:name]}:foo"
+  end
+
+  it "should flush_data for docname" do
+    @c.put_data(:foo1,{'1'=>@product1})
+    docname = @c.docname(:foo1)
+    bucket_index = get_sha1('1')[0..1]
+    store_index = @c.store_index(:foo1)
+    Store.get_store(store_index).db.keys(@c.docname('*')).sort.should == ["#{docname}:#{bucket_index}", "#{docname}:indices"].sort
+    @c.flush_all_documents
+    Store.get_store(store_index).db.keys(@c.docname('*')).should == []
+  end
+
+  it "should flush_data for arrays" do
+    @c.put_list(:foo1,['1', '2', '3'])
+    @c.exists?(:foo1).should == true
+    @c.flush_all_documents
+    @c.exists?(:foo1).should == false
+  end
+
+  it "should get_data for arrays" do
+    @c.put_list(:foo1,['1', '2', '3'])
+    @c.get_data(:foo1, Array).should == ['1', '2', '3']
+    JSON.parse(@c.get_db_doc(:foo1)).should == ['1', '2', '3']
+  end
+
+  it "should rename doc" do
+    @c.put_data(:key1, @data)
+    @c.rename(:key1,:key2)
+    @c.exists?(:key1).should == false
+    @c.get_data(:key2).should == @data
+  end
+
+  it "should operate with individual object" do
+    key = '1'
+    data = {'foo' => 'bar'}
+    @c.put_object(:cd, key, data)
+    obj = @c.get_object(:cd, key)
+    obj.should == data
   end
 end

data/spec/dynamic_adapter_spec.rb

@@ -1,41 +1,38 @@
 require File.join(File.dirname(__FILE__),'spec_helper')
 
 describe "Rhoconnect::Model::DynamicAdapterModel" do
-  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
-    
-    it "should return login when backend service defined" do
-      stub_request(:post, "http://test.com/rhoconnect/authenticate").to_return(:body => "lucas")
-      Rhoconnect.appserver = 'http://test.com'
-      Rhoconnect::Model::DynamicAdapterModel.authenticate('lucas','').should == 'lucas'
-    end
-    
-    it "should query dynamic adapter service" do
-      data = {'1'=>@product1} 
-      stub_request(:post, "http://test.com/rhoconnect/query").with(:headers => {'Content-Type' => 'application/json'}).to_return(:status => 200, :body => data.to_json)
-      da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
-      da.query.should == data
-    end
-    
-    it "should create new object using dynamic adapter" do
-      stub_request(:post, "http://test.com/rhoconnect/create").with(:headers => {'Content-Type' => 'application/json'}).to_return(:body => {:id => 5})
-      da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
-      da.create(@product1).should == {:id => 5}
-    end
-    
-    it "should update object using dynamic adapter" do
-      data = {'id' => 2} 
-      stub_request(:post, "http://test.com/rhoconnect/update").with(:headers => {'Content-Type' => 'application/json'}).to_return(:body => {:id => 5})
-      da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
-      da.update(data).should == {:id => 5}
-    end
-    
-    it "should delete object using dynamic adapter" do
-      data = {'id' => 2}
-      stub_request(:post, "http://test.com/rhoconnect/delete").with(:headers => {'Content-Type' => 'application/json'}).to_return(:body => {:id => 5})
-      da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
-      da.delete(data).should == {:id => 5}
-    end
-    
-    
+  include_examples "SharedRhoconnectHelper", :rhoconnect_data => true
+
+  it "should return login when backend service defined" do
+    stub_request(:post, "http://test.com/rhoconnect/authenticate").to_return(:body => "lucas")
+    Rhoconnect.appserver = 'http://test.com'
+    Rhoconnect::Model::DynamicAdapterModel.authenticate('lucas','').should == 'lucas'
+  end
+
+  it "should query dynamic adapter service" do
+    data = {'1'=>@product1}
+    stub_request(:post, "http://test.com/rhoconnect/query").with(:headers => {'Content-Type' => 'application/json'}).to_return(:status => 200, :body => data.to_json)
+    da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
+    da.query.should == data
+  end
+
+  it "should create new object using dynamic adapter" do
+    stub_request(:post, "http://test.com/rhoconnect/create").with(:headers => {'Content-Type' => 'application/json'}).to_return(:body => {:id => 5})
+    da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
+    da.create(@product1).should == {:id => 5}
+  end
+
+  it "should update object using dynamic adapter" do
+    data = {'id' => 2}
+    stub_request(:post, "http://test.com/rhoconnect/update").with(:headers => {'Content-Type' => 'application/json'}).to_return(:body => {:id => 5})
+    da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
+    da.update(data).should == {:id => 5}
+  end
+
+  it "should delete object using dynamic adapter" do
+    data = {'id' => 2}
+    stub_request(:post, "http://test.com/rhoconnect/delete").with(:headers => {'Content-Type' => 'application/json'}).to_return(:body => {:id => 5})
+    da = Rhoconnect::Model::DynamicAdapterModel.new(@s2,nil,'http://test.com')
+    da.delete(data).should == {:id => 5}
   end
 end

data/spec/generator/generator_spec.rb

@@ -1,66 +1,100 @@
-require File.join(File.dirname(__FILE__),'generator_spec_helper')
+require 'rspec'
+require_relative "../../lib/rhoconnect"
+require_relative "../../generators/rhoconnect"
 
 describe "Generator" do
   appname = 'mynewapp'
   source = 'mysource'
   path = File.expand_path(File.join(File.dirname(__FILE__)))
-  
+
   before(:each) do
     FileUtils.mkdir_p '/tmp'
   end
-  
+
   describe "AppGenerator" do
     it "should complain if no name is specified" do
       lambda {
-        Rhoconnect::AppGenerator.new('/tmp',{})
-      }.should raise_error(Templater::TooFewArgumentsError)
+        Rhoconnect::AppGenerator.new()
+      }.should raise_error(Thor::RequiredArgumentMissingError)
     end
-    
-    before(:each) do
-      @generator = Rhoconnect::AppGenerator.new('/tmp',{},appname)
-    end
-    
+
     it "should create new ruby application files" do
-      SecureRandom.should_receive(:hex).with(64).any_number_of_times
-      [ 
-        'Gemfile',
-        'Rakefile',
-        "controllers/ruby/application_controller.rb",
-        'spec/controllers/ruby/application_controller_spec.rb',
-        'config.ru',
-        'public',
-        'settings/settings.yml',
-        'settings/license.key',
-        'spec/spec_helper.rb'
-      ].each do |template|
-        @generator.should create("/tmp/#{appname}/#{template}")
+      allow(SecureRandom).to receive(:hex).with(64)
+      Dir.chdir '/tmp' do
+        FileUtils.rm_rf(appname)
+        Bundler.with_clean_env do
+          generator = Rhoconnect::AppGenerator.new([appname])
+          generator.invoke_all
+          Dir.chdir(appname) do
+            [
+              'Gemfile',
+              ".rcgemfile",
+              'Rakefile',
+              "controllers/ruby/application_controller.rb",
+              'spec/controllers/ruby/application_controller_spec.rb',
+              'config.ru',
+              'public',
+              'settings/settings.yml',
+              'settings/license.key',
+              'spec/spec_helper.rb'
+            ].each do |template|
+              File.exist?("/tmp/#{appname}/#{template}").should be_true
+            end
+          end
+        end
+      end
+    end
+
+    it "should create new js application files" do
+      allow(SecureRandom).to receive(:hex).with(64)
+      Dir.chdir '/tmp' do
+        FileUtils.rm_rf(appname)
+        Bundler.with_clean_env do
+          Rhoconnect::AppGenerator.start([appname, '--js'])
+          Dir.chdir(appname) do
+            [
+              'Gemfile',
+              ".rcgemfile",
+              'package.json',
+              'Rakefile',
+              'controllers/js/application_controller.js',
+              'config.ru',
+              'public',
+              'settings/settings.yml',
+              'settings/license.key'
+            ].each do |template|
+              File.exist?("/tmp/#{appname}/#{template}").should be_true
+            end
+          end
+        end
       end
     end
   end
-  
+
   describe "SourceGenerator" do
+
     it "should complain if no name is specified" do
       lambda {
-        Rhoconnect::SourceGenerator.new('/tmp',{})
-      }.should raise_error(Templater::TooFewArgumentsError)
-    end
-    
-    before(:each) do
-      FileUtils.rm_rf "/tmp/#{appname}"
-      @app_generator = Rhoconnect::AppGenerator.new('/tmp',{},appname)
-      @app_generator.invoke!
-      Bundler.with_clean_env do
-        @app_generator.after_run
-      end
-      @generator = Rhoconnect::SourceGenerator.new("/tmp/#{appname}",{},source)
+        Rhoconnect::SourceGenerator.new()
+      }.should raise_error(Thor::RequiredArgumentMissingError)
     end
-    
+
     it "should create new source adapter and spec" do
-      @generator.should create("/tmp/#{appname}/models/ruby/#{source}.rb")
-      @generator.should create("/tmp/#{appname}/controllers/ruby/#{source}_controller.rb")
-      @generator.should create("/tmp/#{appname}/spec/models/ruby/#{source}_spec.rb")
-      @generator.should create("/tmp/#{appname}/spec/controllers/ruby/#{source}_controller_spec.rb")
+      Dir.chdir '/tmp' do
+        FileUtils.rm_rf(appname)
+        Bundler.with_clean_env do
+          Rhoconnect::AppGenerator.start([appname])
+          Dir.chdir appname do
+            Rhoconnect::SourceGenerator.start([source])
+
+            File.exist?("/tmp/#{appname}/models/ruby/#{source}.rb").should be_true
+            File.exist?("/tmp/#{appname}/controllers/ruby/#{source}_controller.rb").should be_true
+            File.exist?("/tmp/#{appname}/spec/models/ruby/#{source}_spec.rb").should be_true
+            File.exist?("/tmp/#{appname}/spec/controllers/ruby/#{source}_controller_spec.rb").should be_true
+          end
+        end
+      end
     end
   end
-  
+
 end

data/spec/jobs/bulk_data_job_spec.rb

@@ -1,130 +1,129 @@
 require File.join(File.dirname(__FILE__),'..','spec_helper')
 
 describe "BulkDataJob" do
-  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
+  include_examples "SharedRhoconnectHelper", :rhoconnect_data => true
 
-    after(:each) do
-      delete_data_directory
-    end
-    
-    let(:mock_schema) { {"property" => { "name" => "string", "brand" => "string" }, "version" => "1.0"} }
+  after(:each) do
+    delete_data_directory
+  end
+
+  let(:mock_schema) { {"property" => { "name" => "string", "brand" => "string" }, "version" => "1.0"} }
+
+  it "should create bulk data files from master document" do
+    set_state('test_db_storage' => @data)
+    docname = bulk_data_docname(@a.id,@u.id)
+    expected = { @s_fields[:name] => @data,
+      'FixedSchemaAdapter' => @data
+    }
+    data = BulkData.create(:name => docname,
+      :state => :inprogress,
+      :app_id => @a.id,
+      :user_id => @u.id,
+      :partition_sources => [@s_fields[:name],'FixedSchemaAdapter'],
+      :sources => [@s_fields[:name], 'FixedSchemaAdapter'])
+    do_bulk_data_job("data_name" => data.name)
+    data = BulkData.load(docname)
+    data.completed?.should == true
+    verify_doc_result(@s, {:md => @data,
+                           :md_copy => @data})
+    validate_db(data,expected).should == true
+    File.exists?(data.dbfile+'.rzip').should == true
+    File.exists?(data.dbfile+'.gzip').should == true
+    path = File.join(File.dirname(data.dbfile),'tmp')
+    FileUtils.mkdir_p path
+    unzip_file("#{data.dbfile}.rzip",path)
+    data.dbfile = File.join(path,File.basename(data.dbfile))
+    validate_db(data,expected).should == true
+  end
 
-    it "should create bulk data files from master document" do
-      set_state('test_db_storage' => @data)
+  it "should create bulk data files from master document for specific sources" do
+    set_state('test_db_storage' => @data)
+    docname = bulk_data_docname(@a.id,@u.id)
+    expected = { @s_fields[:name] => {},
+      'FixedSchemaAdapter' => @data
+    }
+    source_existing_data = {'my_key1' => {'my_attrib1' => 'my_val1'}}
+    @s.put_data(:md, source_existing_data)
+    data = BulkData.create(:name => docname,
+      :state => :inprogress,
+      :app_id => @a.id,
+      :user_id => @u.id,
+      :partition_sources => [@s_fields[:name],'FixedSchemaAdapter'],
+      :sources => ['FixedSchemaAdapter'])
+    do_bulk_data_job("data_name" => data.name)
+    data = BulkData.load(docname)
+    data.completed?.should == true
+    verify_doc_result(@s, {:md => source_existing_data,
+                           :md_copy => {}})
+    # skipped source should have :none in the DB - so we pass it for verification
+    @s.sync_type = :none
+    validate_db_file(data.dbfile,[@s_fields[:name], 'FixedSchemaAdapter'], expected).should == true
+    File.exists?(data.dbfile+'.rzip').should == true
+    File.exists?(data.dbfile+'.gzip').should == true
+    path = File.join(File.dirname(data.dbfile),'tmp')
+    FileUtils.mkdir_p path
+    unzip_file("#{data.dbfile}.rzip",path)
+    data.dbfile = File.join(path,File.basename(data.dbfile))
+    validate_db_file(data.dbfile,[@s_fields[:name], 'FixedSchemaAdapter'], expected).should == true
+  end
+
+  it "should create sqlite data with source metadata" do
+    set_state('test_db_storage' => @data)
+    mock_metadata_method([SampleAdapter]) do
       docname = bulk_data_docname(@a.id,@u.id)
-      expected = { @s_fields[:name] => @data,
-        'FixedSchemaAdapter' => @data
-      }
       data = BulkData.create(:name => docname,
         :state => :inprogress,
         :app_id => @a.id,
         :user_id => @u.id,
-        :partition_sources => [@s_fields[:name],'FixedSchemaAdapter'],
-        :sources => [@s_fields[:name], 'FixedSchemaAdapter'])
+        :partition_sources => [@s_fields[:name]],
+        :sources => [@s_fields[:name]])
       do_bulk_data_job("data_name" => data.name)
       data = BulkData.load(docname)
       data.completed?.should == true
       verify_doc_result(@s, {:md => @data,
+                             :metadata => {'foo'=>'bar'}.to_json,
                              :md_copy => @data})
-      validate_db(data,expected).should == true
-      File.exists?(data.dbfile+'.rzip').should == true
-      File.exists?(data.dbfile+'.gzip').should == true
-      path = File.join(File.dirname(data.dbfile),'tmp')
-      FileUtils.mkdir_p path
-      unzip_file("#{data.dbfile}.rzip",path)
-      data.dbfile = File.join(path,File.basename(data.dbfile))
-      validate_db(data,expected).should == true
+      validate_db(data,@s.name => @data).should == true
     end
- 
-    it "should create bulk data files from master document for specific sources" do
-      set_state('test_db_storage' => @data)
+  end
+
+  it "should create sqlite data with source schema" do
+    set_state('test_db_storage' => @data)
+    mock_schema_method([SampleAdapter]) do
       docname = bulk_data_docname(@a.id,@u.id)
-      expected = { @s_fields[:name] => {},
-        'FixedSchemaAdapter' => @data
-      }
-      source_existing_data = {'my_key1' => {'my_attrib1' => 'my_val1'}}
-      @s.put_data(:md, source_existing_data)
       data = BulkData.create(:name => docname,
         :state => :inprogress,
         :app_id => @a.id,
         :user_id => @u.id,
-        :partition_sources => [@s_fields[:name],'FixedSchemaAdapter'],
-        :sources => ['FixedSchemaAdapter'])
+        :partition_sources => [@s_fields[:name]],
+        :sources => [@s_fields[:name]])
       do_bulk_data_job("data_name" => data.name)
       data = BulkData.load(docname)
       data.completed?.should == true
-      verify_doc_result(@s, {:md => source_existing_data,
-                             :md_copy => {}})
-      # skipped source should have :none in the DB - so we pass it for verification
-      @s.sync_type = :none
-      validate_db_file(data.dbfile,[@s_fields[:name], 'FixedSchemaAdapter'], expected).should == true
-      File.exists?(data.dbfile+'.rzip').should == true
-      File.exists?(data.dbfile+'.gzip').should == true
-      path = File.join(File.dirname(data.dbfile),'tmp')
-      FileUtils.mkdir_p path
-      unzip_file("#{data.dbfile}.rzip",path)
-      data.dbfile = File.join(path,File.basename(data.dbfile))
-      validate_db_file(data.dbfile,[@s_fields[:name], 'FixedSchemaAdapter'], expected).should == true
-    end
-    
-    it "should create sqlite data with source metadata" do
-      set_state('test_db_storage' => @data)
-      mock_metadata_method([SampleAdapter]) do
-        docname = bulk_data_docname(@a.id,@u.id)
-        data = BulkData.create(:name => docname,
-          :state => :inprogress,
-          :app_id => @a.id,
-          :user_id => @u.id,
-          :partition_sources => [@s_fields[:name]],
-          :sources => [@s_fields[:name]])
-        do_bulk_data_job("data_name" => data.name)
-        data = BulkData.load(docname)
-        data.completed?.should == true
-        verify_doc_result(@s, {:md => @data,
-                               :metadata => {'foo'=>'bar'}.to_json,
-                               :md_copy => @data})
-        validate_db(data,@s.name => @data).should == true
-      end
-    end
-
-    it "should create sqlite data with source schema" do
-      set_state('test_db_storage' => @data)
-      mock_schema_method([SampleAdapter]) do
-        docname = bulk_data_docname(@a.id,@u.id)
-        data = BulkData.create(:name => docname,
-          :state => :inprogress,
-          :app_id => @a.id,
-          :user_id => @u.id,
-          :partition_sources => [@s_fields[:name]],
-          :sources => [@s_fields[:name]])
-        do_bulk_data_job("data_name" => data.name)
-        data = BulkData.load(docname)
-        data.completed?.should == true        
-        verify_doc_result(@s, {:md => @data,
-                             :md_copy => @data})
-        JSON.parse(@s.get_value(:schema)).should == mock_schema          
-        validate_db(data,@s.name => @data).should == true
-      end
+      verify_doc_result(@s, {:md => @data,
+                           :md_copy => @data})
+      JSON.parse(@s.get_value(:schema)).should == mock_schema
+      validate_db(data,@s.name => @data).should == true
     end
+  end
 
-    it "should delete bulk data if exception is raised" do
-      lambda { 
-        do_bulk_data_job("data_name" => 'broken')
-      }.should raise_error(Exception)
-      Store.get_store(0).db.keys('bulk_data*').should == []
-    end
+  it "should delete bulk data if exception is raised" do
+    lambda {
+      do_bulk_data_job("data_name" => 'broken')
+    }.should raise_error(Exception)
+    Store.get_store(0).db.keys('bulk_data*').should == []
+  end
 
-    it "should delete bulk data if exception is raised" do
-      data = BulkData.create(:name => bulk_data_docname('broken',@u.id),
-        :state => :inprogress,
-        :app_id => 'broken',
-        :user_id => @u.id,
-        :partition_sources => [@s_fields[:name]],
-        :sources => [@s_fields[:name]])
-      lambda { 
-        do_bulk_data_job("data_name" => data.name)
-      }.should raise_error(Exception)
-      Store.get_store(0).db.keys('bulk_data*').should == []
-    end
-  end  
+  it "should delete bulk data if exception is raised" do
+    data = BulkData.create(:name => bulk_data_docname('broken',@u.id),
+      :state => :inprogress,
+      :app_id => 'broken',
+      :user_id => @u.id,
+      :partition_sources => [@s_fields[:name]],
+      :sources => [@s_fields[:name]])
+    lambda {
+      do_bulk_data_job("data_name" => data.name)
+    }.should raise_error(Exception)
+    Store.get_store(0).db.keys('bulk_data*').should == []
+  end
 end