metaforce 0.5.3 → 1.0.0a

data/spec/lib/job/retrieve_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Metaforce::Job::Retrieve do
+  let(:client) { double('metadata client') }
+  let(:job) { described_class.new client }
+
+  describe '.result' do
+    let(:response) { Hashie::Mash.new(success: true) }
+
+    before do
+      client.should_receive(:status).with(job.id, :retrieve).and_return(response)
+    end
+
+    subject { job.result }
+    it { should eq response }
+  end
+
+  describe '.zip_file' do
+    let(:response) { Hashie::Mash.new(success: true, zip_file: 'foobar') }
+
+    before do
+      client.should_receive(:status).with(job.id, :retrieve).and_return(response)
+    end
+
+    subject { job.zip_file }
+    it { should eq "~\x8A\e" }
+  end
+end

data/spec/lib/job_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Metaforce::Job do
+  let(:client) { double('client') }
+  let(:job) { described_class.new(client) }
+
+  describe '.perform' do
+    it 'starts a heart beat' do
+      job.should_receive(:start_heart_beat)
+      job.perform
+    end
+  end
+
+  describe '.on_complete' do
+    it 'allows the user to register an on_complete callback' do
+      client.should_receive(:status).any_number_of_times.and_return(Hashie::Mash.new(done: true, state: 'Completed'))
+      called = false
+      block = lambda { |job| called = true }
+      job.on_complete &block
+      job.perform
+      expect(called).to be_true
+    end
+  end
+
+  describe '.on_error' do
+    it 'allows the user to register an on_error callback' do
+      client.should_receive(:status).any_number_of_times.and_return(Hashie::Mash.new(done: true, state: 'Error'))
+      called = false
+      block = lambda { |job| called = true }
+      job.on_error &block
+      job.perform
+      expect(called).to be_true
+    end
+  end
+
+  describe '.status' do
+    before do
+      client.should_receive(:status)
+    end
+
+    subject { job.status }
+    it { should be_nil }
+  end
+
+  describe '.done?' do
+    subject { job.done? }
+
+    context 'when done' do
+      before do
+        client.should_receive(:status).and_return(Hashie::Mash.new(done: true))
+      end
+
+      it { should be_true }
+    end
+
+    context 'when not done' do
+      before do
+        client.should_receive(:status).and_return(Hashie::Mash.new(done: false))
+      end
+
+      it { should be_false }
+    end
+  end
+
+  describe '.state' do
+    subject { job.state }
+
+    context 'when done' do
+      before do
+        client.should_receive(:status).twice.and_return(Hashie::Mash.new(done: true, state: 'Completed'))
+      end
+
+      it { should eq 'Completed' }
+    end
+
+    context 'when not done' do
+      before do
+        client.should_receive(:status).once.and_return(Hashie::Mash.new(done: false))
+      end
+
+      it { should be_false }
+    end
+  end
+
+  %w[Queued InProgress Completed Error].each do |state|
+    describe ".#{state.underscore}?" do
+      before do
+        client.should_receive(:status).twice.and_return(Hashie::Mash.new(done: true, state: state))
+      end
+
+      subject { job.send(:"#{state.underscore}?") }
+      it { should be_true }
+    end
+  end
+end

data/spec/lib/login_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Metaforce::Login do
+  let(:klass) { described_class.new('foo', 'bar', 'whizbang') }
+
+  describe '.login' do
+    before do
+      savon.expects(:login).with(:username => 'foo', :password => 'barwhizbang').returns(:success)
+    end
+
+    subject { klass.login }
+    it { should be_a Hash }
+    its([:session_id])          { should eq '00DU0000000Ilbh!AQoAQHVcube9Z6CRlbR9Eg8ZxpJlrJ6X8QDbnokfyVZItFKzJsLH' \
+                                  'IRGiqhzJkYsNYRkd3UVA9.s82sbjEbZGUqP3mG6TP_P8' }
+    its([:metadata_server_url]) { should eq 'https://na12-api.salesforce.com/services/Soap/m/23.0/00DU0000000Albh' }
+    its([:server_url])          { should eq 'https://na12-api.salesforce.com/services/Soap/u/23.0/00DU0000000Ilbh' }
+  end
+end

data/spec/lib/manifest_spec.rb

@@ -1,181 +1,35 @@
 require "spec_helper"
 
 describe Metaforce::Manifest do
-
-  before(:all) do
-    @package_xml = File.open(File.join(File.dirname(__FILE__), '../fixtures/package.xml'), 'r').read
-  end
-
-  before(:each) do
-    @package_hash = {
-      :apex_class => ['TestClass', 'AnotherClass'],
+  let(:package_xml) { File.open(File.join(File.dirname(__FILE__), '../fixtures/package.xml'), 'r').read }
+  let(:package_hash) do
+    { :apex_class => ['TestClass', 'AnotherClass'],
       :apex_component => ['Component'],
-      :static_resource => ['Assets']
-    }
-  end
-
-  describe ".new" do
-    context "when given a hash" do
-      describe ".to_xml" do
-
-        it "returns a string containing xml" do
-          package = Metaforce::Manifest.new(@package_hash)
-          response = package.to_xml
-          response.should eq(@package_xml)
-        end
-
-      end
-    end
-    context "when given a string" do
-      describe ".to_hash" do
-
-        it "returns the xml content as a hash" do
-          package = Metaforce::Manifest.new(@package_xml)
-          response = package.to_hash
-          response.should eq(@package_hash)
-        end
-
-      end
-    end
-  end
-
-  describe ".add" do
-
-    it "can add additional components" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.add(:apex_class, 'AdditionalClass')
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['TestClass', 'AnotherClass', 'AdditionalClass'],
-        :apex_component => ['Component'],
-        :static_resource => ['Assets']
-      }
-      response.should eq(@package_hash)
-    end
-
-    it "can add additional components from an array" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.add(:apex_class, ['class1', 'class2'])
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['TestClass', 'AnotherClass', 'class1', 'class2'],
-        :apex_component => ['Component'],
-        :static_resource => ['Assets']
-      }
-      response.should eq(@package_hash)
-    end
-
-    it "strips directories and extensions" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.add(:apex_class, 'src/classes/AdditionalClass.cls')
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['TestClass', 'AnotherClass', 'AdditionalClass'],
-        :apex_component => ['Component'],
-        :static_resource => ['Assets']
-      }
-      response.should eq(@package_hash)
-    end
-
+      :static_resource => ['Assets'] }
   end
+  let(:package) { package_xml }
+  let(:manifest) { described_class.new(package) }
 
-  describe ".remove" do
-
-    it "can remove components" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.remove(:apex_class, 'TestClass')
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['AnotherClass'],
-        :apex_component => ['Component'],
-        :static_resource => ['Assets']
-      }
-      response.should eq(@package_hash)
-    end
-
-    it "can remove components in an array" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.remove(:apex_class, ['TestClass', 'AnotherClass'])
-      response = package.to_hash
-      @package_hash = {
-        :apex_component => ['Component'],
-        :static_resource => ['Assets']
-      }
-      response.should eq(@package_hash)
-    end
-
-    it "strips directories and extensions" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.remove(:apex_class, 'src/classes/TestClass.cls')
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['AnotherClass'],
-        :apex_component => ['Component'],
-        :static_resource => ['Assets']
-      }
-      response.should eq(@package_hash)
-    end
-
+  describe '.to_xml' do
+    let(:package) { package_hash }
+    subject { manifest.to_xml }
+    it { should eq package_xml }
   end
 
-  describe ".only" do
-
-    it "filters the components based on a list of files" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.only(['classes/TestClass'])
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['TestClass']
-      }
-      response.should eq(@package_hash)
-    end
-
-    it "ignores file extensions" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.only(['classes/TestClass.cls', 'components/Component.component'])
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['TestClass'],
-        :apex_component => ['Component']
-      }
-      response.should eq(@package_hash)
-    end
-
-    it "strips any leading directories" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.only(['src/classes/TestClass.cls', 'src/components/Component.component'])
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['TestClass'],
-        :apex_component => ['Component']
-      }
-      response.should eq(@package_hash)
-    end
-
-    it "ignores case of folder" do
-      package = Metaforce::Manifest.new(@package_hash)
-      package.only(['src/Classes/TestClass.cls', 'src/Components/Component.component'])
-      response = package.to_hash
-      @package_hash = {
-        :apex_class => ['TestClass'],
-        :apex_component => ['Component']
-      }
-      response.should eq(@package_hash)
-    end
-
+  describe '.to_hash' do
+    let(:package) { package_xml }
+    subject { manifest.to_hash }
+    it { should eq package_hash }
   end
 
-  describe ".to_package" do
-
-    it "returns a in package format" do
-        package = Metaforce::Manifest.new(@package_hash)
-        response = package.to_package
-        response.should eq([
-          { :members => ["TestClass", "AnotherClass"], :name => "ApexClass" },
-          { :members => ["Component"], :name => "ApexComponent" },
-          { :members => ["Assets"], :name => "StaticResource" }
-        ])
+  describe '.to_package' do
+    subject { manifest.to_package }
+    it do
+      should eq [
+        { :members => ['TestClass', 'AnotherClass'], :name => 'ApexClass' },
+        { :members => ['Component'], :name => 'ApexComponent' },
+        { :members => ['Assets'], :name => 'StaticResource' }
+      ]
     end
-
   end
 end

data/spec/lib/metadata/client_spec.rb

@@ -1,230 +1,135 @@
-require "spec_helper"
-require "tempfile"
+require 'spec_helper'
 
 describe Metaforce::Metadata::Client do
+  let(:client) { described_class.new(:session_id => 'foobar', :metadata_server_url => 'https://na12-api.salesforce.com/services/Soap/u/23.0/00DU0000000Ilbh') }
 
-  before(:each) do
-    savon.expects(:login).with(:username => 'valid', :password => 'password').returns(:success)
-  end
-
-  let(:client) do
-    Metaforce::Metadata::Client.new(:username => 'valid', :password => 'password')
-  end
-  
-  describe ".list" do
-
-    it "returns an array" do
-      savon.expects(:list_metadata).with(:queries => [ :type => "ApexClass"]).returns(:objects)
-      client.list(:type => "ApexClass").should be_an(Array)
-    end
-
-    it "returns an empty array when no results are returned" do
-      savon.expects(:list_metadata).with(:queries => [ :type => "ApexClass"]).returns(:no_result)
-      client.list(:type => "ApexClass").should be_an(Array)
-    end
-
-    it "accepts a symbol" do
-      savon.expects(:list_metadata).with(:queries => [ :type => "ApexClass"]).returns(:no_result)
-      client.list(:apex_class).should be_an(Array)
-    end
-
-    it "accepts a string" do
-      savon.expects(:list_metadata).with(:queries => [ :type => "ApexClass"]).returns(:no_result)
-      client.list("ApexClass").should be_an(Array)
-    end
-
-  end
-
-  it "should respond to dynamically defined list methods" do
-    savon.expects(:describe_metadata).returns(:success)
-    savon.expects(:list_metadata).with(:queries => [ :type => "ApexClass"]).returns(:no_result)
-    client.list_apex_class.should be_an(Array)
+  it_behaves_like 'a client'
 
-    expect { client.list_undefined_type }.to raise_error(NoMethodError)
-  end
-
-  describe ".describe" do
-    context "when given valid information" do
-
-      it "returns a hash" do
-        savon.expects(:describe_metadata).returns(:success)
-        client.describe.should be_a(Hash)
+  describe '.list_metadata' do
+    context 'with a single symbol' do
+      before do
+        savon.expects(:list_metadata).with(:queries => [{:type => 'ApexClass'}]).returns(:objects)
       end
 
-      it "caches the response" do
-        savon.expects(:describe_metadata).returns(:success)
-        client.describe.should be_a(Hash)
-        expect { client.describe }.to_not raise_error
-      end
-
-    end
-  end
-
-  describe ".metadata_objects" do
-    it "returns the :metadata_objects key from the describe call" do
-      savon.expects(:describe_metadata).returns(:success)
-      client.metadata_objects.should be_a(Array)
+      subject { client.list_metadata(:apex_class) }
+      it { should be_an Array }
     end
-  end
 
-  describe ".describe!" do
-    context "when given valid information" do
-
-      it "returns a hash" do
-        savon.expects(:describe_metadata).returns(:success)
-        client.describe!.should be_a(Hash)
-      end
-
-      it "doesn't cache the response" do
-        savon.expects(:describe_metadata).returns(:success)
-        client.describe!.should be_a(Hash)
-        savon.expects(:describe_metadata).returns(:success)
-        expect { client.describe! }.to_not raise_error
+    context 'with a single string' do
+      before do
+        savon.expects(:list_metadata).with(:queries => [{:type => 'ApexClass'}]).returns(:objects)
       end
 
+      subject { client.list_metadata('ApexClass') }
+      it { should be_an Array }
     end
   end
 
-  describe ".status" do
-    context "when given an invalid id" do
-
-      it "raises an" do
-        expect { client.status("badId") }.to raise_error
-      end
-
-    end
-    context "when given an id of a result that has completed" do
-
-      it "returns a hash and the :done key contains true" do
-        savon.expects(:check_status).with(:ids => [ "04sU0000000WNWoIAO" ]).returns(:done)
-        status = client.status("04sU0000000WNWoIAO")
-        status.should be_a(Hash)
-        status[:done].should eq(true)
+  describe '.describe' do
+    context 'with no version' do
+      before do
+        savon.expects(:describe_metadata).with(nil).returns(:success)
       end
 
+      subject { client.describe }
+      it { should be_a Hash }
     end
-    context "when given an id of a result that has not completed" do
 
-      it "returns a hash and the :done key contains false" do
-        savon.expects(:check_status).with(:ids => [ "04sU0000000WNWoIAo" ]).returns(:not_done)
-        status = client.status("04sU0000000WNWoIAo")
-        status.should be_a(Hash)
-        status[:done].should eq(false)
+    context 'with a version' do
+      before do
+        savon.expects(:describe_metadata).with(:api_version => '18.0').returns(:success)
       end
 
+      subject { client.describe('18.0') }
+      it { should be_a Hash }
     end
-    context "when given and id of a deploy that has completed" do
+  end
 
-      it "returns a hash" do
-        savon.expects(:check_deploy_status).with(:ids => [ "04sU0000000WNWoIAO" ]).returns(:done)
-        status = client.status("04sU0000000WNWoIAO", :deploy)
-        status.should be_a(Hash)
+  describe '.status' do
+    context 'with a single id' do
+      before do
+        savon.expects(:check_status).with(:ids => ['1234']).returns(:done)
       end
 
+      subject { client.status '1234' }
+      it { should be_a Hash }
     end
   end
 
-  describe ".done?" do
-    context "when given an id of a result that has completed" do
-
-      it "returns true" do
-        savon.expects(:check_status).with(:ids => [ "04sU0000000WNWoIAO" ]).returns(:done)
-        client.done?("04sU0000000WNWoIAO").should eq(true)
-      end
-
+  describe '._deploy' do
+    before do
+      savon.expects(:deploy).with(:zip_file => 'foobar', :deploy_options => {}).returns(:in_progress)
     end
-    context "when given an id of a result that has not completed" do
 
-      it "returns false" do
-        savon.expects(:check_status).with(:ids => [ "04sU0000000WNWoIAo" ]).returns(:not_done)
-        client.done?("04sU0000000WNWoIAo").should eq(false)
-      end
+    subject { client._deploy('foobar') }
+    it { should be_a Hash }
+  end
 
-    end
+  describe '.deploy' do
+    subject { client.deploy File.expand_path('../../path/to/zip') }
+    it { should be_a Metaforce::Job::Deploy }
   end
 
-  describe ".deploy" do
+  describe '._retrieve' do
+    let(:options) { double('options') }
 
-    before(:each) do
-      Metaforce::Metadata::Client.any_instance.stubs(:create_deploy_file).returns('')
+    before do
+      savon.expects(:retrieve).with(:retrieve_request => options).returns(:in_progress)
     end
-    
-    context "when given a directory to deploy" do
-
-      it "deploys the directory and returns a transaction" do
-        savon.expects(:deploy).with(:zip_file => '', :deploy_options => {}).returns(:in_progress)
-        savon.expects(:check_status).with(:ids => ['04sU0000000WNWoIAO']).returns(:done);
-        deployment = client.deploy(File.expand_path('../../../fixtures/sample', __FILE__))
-        deployment.should be_a(Metaforce::Transaction)
-        deployment.id.should eq("04sU0000000WNWoIAO")
-      end
 
-    end
-
-    it "allows deploy options to be configured via a hash" do
-      savon.expects(:deploy).with(:zip_file => '', :deploy_options => { :run_all_tests => true }).returns(:in_progress)
-      savon.expects(:check_status).with(:ids => ['04sU0000000WNWoIAO']).returns(:done);
-      expect {
-        client.deploy('', :options => { :run_all_tests => true })
-      }.to_not raise_error
-    end
+    subject { client._retrieve(options) }
+    it { should be_a Hash }
+  end
 
+  describe '.retrieve' do
+    subject { client.retrieve }
+    it { should be_a Metaforce::Job::Retrieve }
   end
 
-  describe ".retrieve" do
+  describe '.retrieve_unpackaged' do
+    let(:manifest) { Metaforce::Manifest.new(:custom_object => ['Account']) }
+    subject { client.retrieve_unpackaged(manifest) }
+    it { should be_a Metaforce::Job::Retrieve }
+  end
 
-    let(:manifest) do
-      Metaforce::Manifest.new(File.open(File.expand_path('../../../fixtures/sample/src/package.xml', __FILE__)).read)
+  describe '._create' do
+    before do
+      savon.expects(:create).with(:metadata => [{:full_name => 'component', :label => 'test', :content => "Zm9vYmFy\n"}], :attributes! => {'ins0:metadata' => {'xsi:type' => 'ins0:ApexComponent'}}).returns(:in_progress)
     end
 
-    describe ".retrieve_unpackaged" do
-
-      context "when given a manifest file" do
-        before(:each) do
-          savon.expects(:retrieve).with(:retrieve_request => { :api_version => Metaforce.configuration.api_version, :single_package => true, :unpackaged => { :types => manifest.to_package } }).returns(:in_progress)
-          savon.expects(:check_status).with(:ids => ['04sU0000000WkdIIAS']).returns(:done)
-          savon.expects(:check_retrieve_status).with(:ids => ['04sU0000000WkdIIAS']).returns(:success)
-        end
-
-        it "returns a valid retrieve result" do
-          retrieval = client.retrieve_unpackaged(manifest)
-          retrieval.done?
-          result = retrieval.result
-          result.should be_a(Hash)
-        end
+    subject { client._create(:apex_component, :full_name => 'component', :label => 'test', :content => 'foobar') }
+    it { should be_a Hash }
+  end
 
+  describe '._delete' do
+    context 'with a single name' do
+      before do
+        savon.expects(:delete).with(:metadata => [{:full_name => 'component'}], :attributes! => {'ins0:metadata' => {'xsi:type' => 'ins0:ApexComponent'}}).returns(:in_progress)
       end
 
-      context "when given the path to a manifest file" do
-        before(:each) do
-          savon.expects(:retrieve).with(:retrieve_request => { :api_version => Metaforce.configuration.api_version, :single_package => true, :unpackaged => { :types => manifest.to_package } }).returns(:in_progress)
-          savon.expects(:check_status).with(:ids => ['04sU0000000WkdIIAS']).returns(:done)
-          savon.expects(:check_retrieve_status).with(:ids => ['04sU0000000WkdIIAS']).returns(:success)
-        end
-
-        it "returns a valid retrieve result" do
-          retrieval = client.retrieve_unpackaged(File.expand_path('../../../fixtures/sample/src/package.xml', __FILE__))
-          retrieval.done?
-          result = retrieval.result
-          result.should be_a(Hash)
-        end
+      subject { client._delete(:apex_component, 'component') }
+      it { should be_a Hash }
+    end
 
+    context 'with multiple' do
+      before do
+        savon.expects(:delete).with(:metadata => [{:full_name => 'component1'}, {:full_name => 'component2'}], :attributes! => {'ins0:metadata' => {'xsi:type' => 'ins0:ApexComponent'}}).returns(:in_progress)
       end
 
-      context "when given extra retrieve options" do
-        before(:each) do
-          savon.expects(:retrieve).with(:retrieve_request => { :api_version => Metaforce.configuration.api_version, :single_package => true, :unpackaged => { :types => manifest.to_package }, :extra => true }).returns(:in_progress)
-          savon.expects(:check_status).with(:ids => ['04sU0000000WkdIIAS']).returns(:done);
-        end
-
-        it "merges the options" do
-          expect {
-            retrieval = client.retrieve_unpackaged(File.expand_path('../../../fixtures/sample/src/package.xml', __FILE__), :options => { :extra => true })
-          }.to_not raise_error
-        end
+      subject { client._delete(:apex_component, 'component1', 'component2') }
+      it { should be_a Hash }
+    end
+  end
 
-      end
+  describe '._update' do
+    before do
+      savon.expects(:update).with(:metadata => {:current_name => 'old_component', :metadata => [{:full_name => 'component', :label => 'test', :content => "Zm9vYmFy\n"}], :attributes! => {:metadata => {'xsi:type' => 'ins0:ApexComponent'}}}).returns(:in_progress)
     end
 
+    subject { client._update(:apex_component, 'old_component', :full_name => 'component', :label => 'test', :content => 'foobar') }
+    it { should be_a Hash }
   end
 end
+
+
+

data/spec/lib/metaforce_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Metaforce do
+  describe '#new' do
+    let(:klass) { described_class.new(session_id: 'foobar') }
+    subject { klass }
+
+    it { should be_a Metaforce::Client }
+  end
+
+  describe '#login' do
+    let(:args) { {:username => 'foo', :password => 'foobar', :security_token => 'whizbang'} }
+
+    it 'proxies the login call' do
+      Metaforce::Login.should_receive(:new).with('foo', 'foobar', 'whizbang').and_call_original
+      Metaforce::Login.any_instance.should_receive(:login)
+      described_class.login args
+    end
+  end
+end