metaforce-beta 1.2.0

data/spec/fixtures/requests/retrieve/in_progress.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns="http://soap.sforce.com/2006/04/metadata">
+  <soapenv:Body>
+    <retrieveResponse>
+      <result>
+        <done>false</done>
+        <id>04sU0000000WkdIIAS</id>
+        <state>InProgress</state>
+      </result>
+    </retrieveResponse>
+  </soapenv:Body>
+</soapenv:Envelope>

data/spec/fixtures/requests/send_email/success.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns="urn:partner.soap.sforce.com"><soapenv:Body><sendEmailResponse><result><success>true</success></result></sendEmailResponse></soapenv:Body></soapenv:Envelope>

data/spec/fixtures/requests/update/in_progress.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns="http://soap.sforce.com/2006/04/metadata">
+  <soapenv:Body>
+    <updateResponse>
+      <result>
+        <done>false</done>
+        <id>04sU0000000WNWoIAO</id>
+        <state>InProgress</state>
+      </result>
+    </updateResponse>
+  </soapenv:Body>
+</soapenv:Envelope>

data/spec/lib/cli_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'metaforce/cli'
+
+describe Metaforce::CLI do
+  before do
+    Metaforce::Client.any_instance.stub(:deploy).and_return(double('deploy job').as_null_object)
+    Metaforce::Client.any_instance.stub(:retrieve).and_return(double('retrieve job').as_null_object)
+    subject.stub(:config).and_return(nil)
+  end
+
+  describe 'credentials' do
+    # let(:output) { capture(:stdout) { subject.deploy('./path') } }
+
+    # context 'when supplied credentials from the command line' do
+    #   let(:options) { indifferent_hash(:username => 'foo', :password => 'bar', :security_token => 'token', :deploy_options => {}) }
+
+    #   it 'uses supplied credentials from command line' do
+    #     subject.options = options
+    #     Metaforce.should_receive(:new).with(indifferent_hash(options).slice(:username, :password, :security_token)).and_call_original
+    #     # output.should include('Deploying: ./path')
+    #     expect { subject.deploy('./path') }.to output('Deploying: ./path {}').to_stdout
+    #   end
+    # end
+
+    context 'when supplied credentials from config file' do
+      let(:options) { indifferent_hash(:environment => 'production', :deploy_options => {}) }
+      let(:config) { { 'username' => 'foo', 'password' => 'bar', 'security_token' => 'token' } }
+
+      it 'uses credentials from the config file' do
+        subject.options = options
+        subject.stub(:config).and_return('production' => config)
+        Metaforce.should_receive(:new).with(indifferent_hash(config)).and_call_original
+        # output.should include('Deploying: ./path')
+        expect { subject.deploy('./path') }.to output("Deploying: ./path {}\n").to_stdout
+      end
+    end
+  end
+
+  def indifferent_hash(hash)
+    Thor::CoreExt::HashWithIndifferentAccess.new(hash)
+  end
+end

data/spec/lib/client_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Metaforce::Client do
+  let(:options) { { session_id: 'foobar' } }
+  let(:client) { described_class.new(options) }
+
+  describe '.metadata' do
+    subject { client.metadata }
+    it { should be_a Metaforce::Metadata::Client }
+  end
+
+  describe '.services' do
+    subject { client.services }
+    it { should be_a Metaforce::Services::Client }
+  end
+
+  describe '.method_missing' do
+    [:services, :metadata].each do |type|
+      context "when the #{type} client responds to method" do
+        it 'proxies to the method' do
+          # client.send(type).should_receive(:respond_to?).with(:foobar, false).and_return(true)
+          client.send(type).should_receive(:foobar)
+          client.foobar
+        end
+      end
+    end
+
+    context 'when neither client responds to method' do
+      it 'raises an exception' do
+        expect { client.foobar }.to raise_error NoMethodError
+      end
+    end
+  end
+
+  describe '.inspect' do
+    subject { client.inspect }
+    it { should eq '#<Metaforce::Client @options={:session_id=>"foobar"}>' }
+  end
+end

data/spec/lib/config_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Metaforce do
+  describe '.configuration' do
+    subject { Metaforce.configuration }
+    it { should set_default(:api_version).to('26.0') }
+    it { should set_default(:host).to('login.salesforce.com') }
+    it { should set_default(:endpoint).to('https://login.salesforce.com/services/Soap/u/26.0') }
+    it { should set_default(:partner_wsdl).to(File.expand_path('../../../wsdl/26.0/partner.xml', __FILE__)) }
+    it { should set_default(:metadata_wsdl).to(File.expand_path('../../../wsdl/26.0/metadata.xml', __FILE__)) }
+  end
+end

data/spec/lib/job/deploy_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Metaforce::Job::Deploy do
+  let(:client) { double('metadata client') }
+  let(:path) { File.expand_path('../../../fixtures/payload.zip', __FILE__) }
+  let(:job) { described_class.new client, path }
+
+  describe '.perform' do
+    subject { job.perform }
+
+    context 'when the path is a file' do
+      before do
+        client.should_receive(:_deploy).with(/^UEsDBA.*/, {}).and_return(Hashie::Mash.new(id: '1234'))
+        client.should_receive(:status).at_least(1).times.and_return(Hashie::Mash.new(done: true, state: 'Completed'))
+      end
+
+      it { should eq job }
+      its(:id) { should eq '1234' }
+    end
+
+    context 'when the path is a directory' do
+      before do
+        client.should_receive(:_deploy).with(/^UEsDBB.*/, {}).and_return(Hashie::Mash.new(id: '1234'))
+        client.should_receive(:status).at_least(1).times.and_return(Hashie::Mash.new(done: true, state: 'Completed'))
+      end
+
+      let(:path) { File.expand_path('../../../fixtures', __FILE__) }
+      it { should eq job }
+      its(:id) { should eq '1234' }
+    end
+  end
+
+  describe '.result' do
+    let(:response) { Hashie::Mash.new(success: true) }
+
+    before do
+      client.should_receive(:status).with(job.id, :deploy).and_return(response)
+    end
+
+    subject { job.result }
+    it { should eq response }
+  end
+
+  describe '.success?' do
+    let(:response) { Hashie::Mash.new(success: true) }
+
+    before do
+      client.should_receive(:status).with(job.id, :deploy).and_return(response)
+    end
+
+    subject { job.success? }
+    it { should be_truthy }
+  end
+end

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.bytes }
+    it { should eq [126, 138, 27, 106] }
+  end
+end

data/spec/lib/job_spec.rb

@@ -0,0 +1,111 @@
+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 '.started?' do
+    subject { job.started? }
+
+    context 'when .perform has been called and an @id has been set' do
+      before do
+        job.instance_variable_set(:@id, '1234')
+      end
+
+      it { should be_truthy }
+    end
+
+    context 'when .perform has not been called and no @id has been set' do
+      it { should be_falsey }
+    end
+  end
+
+  describe '.on_complete' do
+    it 'allows the user to register an on_complete callback' do
+      client.should_receive(:status).at_least(1).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_truthy
+    end
+  end
+
+  describe '.on_error' do
+    it 'allows the user to register an on_error callback' do
+      client.should_receive(:status).at_least(1).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_truthy
+    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_truthy }
+    end
+
+    context 'when not done' do
+      before do
+        client.should_receive(:status).and_return(Hashie::Mash.new(done: false))
+      end
+
+      it { should be_falsey }
+    end
+  end
+
+  describe '.state' do
+    subject { job.state }
+
+    context 'when done' do
+      before do
+        client.should_receive(:status).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_falsey }
+    end
+  end
+
+  %w[Queued InProgress Completed Error].each do |state|
+    describe ".#{state.underscore}?" do
+      before do
+        client.should_receive(:status).and_return(Hashie::Mash.new(done: true, state: state))
+      end
+
+      subject { job.send(:"#{state.underscore}?") }
+      it { should be_truthy }
+    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

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Metaforce::Manifest do
+  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
+  let(:package) { package_xml }
+  let(:manifest) { described_class.new(package) }
+
+  describe '.to_xml' do
+    let(:package) { package_hash }
+    subject { manifest.to_xml }
+    it { should eq package_xml }
+  end
+
+  describe '.to_hash' do
+    let(:package) { package_xml }
+    subject { manifest.to_hash }
+    it { should eq package_hash }
+  end
+
+  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

@@ -0,0 +1,135 @@
+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') }
+
+  it_behaves_like 'a client'
+
+  describe '.list_metadata' do
+    context 'with a single symbol' do
+      before do
+        savon.expects(:list_metadata).with(:queries => [{:type => 'ApexClass'}]).returns(:objects)
+      end
+
+      subject { client.list_metadata(:apex_class) }
+      it { should be_an Array }
+    end
+
+    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 '.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 '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
+  end
+
+  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 '._deploy' do
+    before do
+      savon.expects(:deploy).with(:zip_file => 'foobar', :deploy_options => {}).returns(:in_progress)
+    end
+
+    subject { client._deploy('foobar') }
+    it { should be_a Hash }
+  end
+
+  describe '.deploy' do
+    subject { client.deploy File.expand_path('../../path/to/zip') }
+    it { should be_a Metaforce::Job::Deploy }
+  end
+
+  describe '._retrieve' do
+    let(:options) { double('options') }
+
+    before do
+      savon.expects(:retrieve).with(:retrieve_request => options).returns(:in_progress)
+    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_unpackaged' do
+    let(:manifest) { Metaforce::Manifest.new(:custom_object => ['Account']) }
+    subject { client.retrieve_unpackaged(manifest) }
+    it { should be_a Metaforce::Job::Retrieve }
+  end
+
+  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
+
+    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
+
+      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
+
+      subject { client._delete(:apex_component, 'component1', 'component2') }
+      it { should be_a Hash }
+    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
+
+
+