ey-core 3.0.0

data/spec/addons_and_vars_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe 'addons' do
+  let!(:client) { create_client }
+
+  context "with user and account" do
+    let!(:account) { create_account(client: client) }
+
+    it "list addons" do
+      expect(account.addons.all).to be_empty
+    end
+
+    describe "create addon" do
+      before do
+        @addon = account.addons.create!(
+          :name => "fooooo",
+          :sso_url => "http://example.com",
+          :vars => {foo: "bar", baz: "bob"})
+      end
+
+      it "creates the addon" do
+        expect(@addon.name).to eq "fooooo"
+        expect(@addon.sso_url).to eq "http://example.com"
+        expect(@addon.vars).to eq({"foo" => "bar", "baz" => "bob"})
+      end
+
+      it "shows in the list" do
+        expect(account.addons.all.size).to eq 1
+        addon = account.addons.first
+        expect(addon.name).to eq "fooooo"
+        expect(addon.vars).to eq({"foo" => "bar", "baz" => "bob"})
+      end
+
+      it "can be fetched" do
+        addon_refetched = account.addons.get(@addon.id)
+        expect(addon_refetched.id).to eq @addon.id
+        expect(addon_refetched.name).to eq "fooooo"
+        expect(addon_refetched.vars).to eq({"foo" => "bar", "baz" => "bob"})
+      end
+
+      #Effectively also tests that the resource_url is set in all the ways an addon can be fetched
+      it "can be updated (3 ways)" do
+        tryit = Proc.new do |add, name, vars|
+          add.name = name
+          add.vars = vars
+          add.save!
+          add.reload
+          expect(add.name).to eq name
+          expect(add.vars).to eq vars
+        end
+        tryit.call(account.addons.get(@addon.id), "fetchedwithget", "fetchsingle" => "GET")
+        tryit.call(account.addons.first, "fetchedfromlist", "fetchmulti" => "GET")
+        tryit.call(@addon, "createresult", "created" => "POST")
+      end
+
+      it "can be destroyed" do
+        @addon.destroy
+        expect(account.addons.all.size).to eq 0
+      end
+    end
+  end
+end

data/spec/addresses_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe 'addresses' do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  it "creates an address" do
+    request = client.addresses.create!(provider: provider, location: "us-west-2")
+    address = request.resource!
+    expect(address.id).not_to be_nil
+    expect(address.ip_address).not_to be_nil
+    expect(address.provisioned_id).not_to be_nil
+    expect(address.provider).to eq(provider)
+  end
+
+  context "with an address" do
+    let(:location) { "us-west-2" }
+    let!(:address) { client.addresses.all.find{|a| a.location.match(location) && a.server_id.nil?} || client.addresses.create!(provider: provider, location: location).resource! }
+
+    it "searches by provisioned_id" do
+      addresses = client.addresses.all(provisioned_id: address.provisioned_id)
+      expect(addresses.size).to eq(1)
+      expect(addresses.first).to eq(address)
+    end
+
+    it "searches by ip_address" do
+      addresses = client.addresses.all(ip_address: address.ip_address)
+      expect(addresses.size).to eq(1)
+      expect(addresses.first).to eq(address)
+    end
+
+    it "lists addresses" do
+      addresses = client.addresses.all
+      expect(addresses.to_a).to include(address)
+    end
+
+    context "with a server" do
+      let!(:environment) { create_environment(account: account, name: Faker::Name.first_name, configuration: {"type" => "cluster"}) }
+
+      it "attaches and detach an address from a server" do
+        server = environment.servers.first(role: "app_master")
+
+        expect(server).to be
+
+        address.attach(server).ready!
+
+        address = server.reload.address
+        address.detach.ready!
+
+        expect(server.reload.address).to be_nil
+        expect(address.reload.server).to be_nil
+      end
+    end
+  end
+end

data/spec/alerts_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe 'alerts' do
+  let(:client) { create_client }
+  let(:alert_params) { {
+    :message     => Faker::Lorem.sentence(1),
+    :description => Faker::Hacker.verb,
+    :severity    => "warning",
+    :name        => Faker::Hacker.noun,
+    :external_id => SecureRandom.uuid,
+  } }
+
+  it 'should fail to create an alert with no resource' do
+    expect { client.alerts.create!(alert_params) }.to raise_error Ey::Core::Response::Unprocessable
+  end
+
+  context 'with a database server' do
+    let(:database_server) { create_database_service(client: client).servers.first }
+
+    it 'should create an alert' do
+      alert = nil
+      expect {
+        alert = database_server.alerts.create!(alert_params)
+      }.to change  { client.alerts.size          }.by(1).
+        and change { database_server.alerts.size }.by(1)
+
+      expect(alert.database_server).to eq(database_server)
+      expect(alert.resource).to        eq(database_server)
+
+      expect(alert.description).to     eq(alert_params[:description])
+      expect(alert.external_id).to     eq(alert_params[:external_id])
+      expect(alert.finished_at).to     eq(nil)
+      expect(alert.message).to         eq(alert_params[:message])
+      expect(alert.name).to            eq(alert_params[:name])
+      expect(alert.severity).to        eq(alert_params[:severity])
+
+      alert.reload
+
+      expect(alert.database_server).to eq(database_server)
+      expect(alert.resource).to        eq(database_server)
+
+      expect(alert.description).to     eq(alert_params[:description])
+      expect(alert.external_id).to     eq(alert_params[:external_id])
+      expect(alert.finished_at).to     eq(nil)
+      expect(alert.message).to         eq(alert_params[:message])
+      expect(alert.name).to            eq(alert_params[:name])
+      expect(alert.severity).to        eq(alert_params[:severity])
+    end
+  end
+
+  context 'with a server' do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:environment) { create_environment(account: account, name: Faker::Name.first_name) }
+
+    it 'should create an alert' do
+      server = client.servers.all.first
+      alert  = nil
+
+      expect {
+        alert = server.alerts.create!(alert_params)
+      }.to change  { client.alerts.size }.by(1).
+        and change { server.alerts.size }.by(1)
+
+      expect(alert.message).to     eq(alert_params[:message])
+      expect(alert.description).to eq(alert_params[:description])
+      expect(alert.severity).to    eq(alert_params[:severity])
+      expect(alert.name).to        eq(alert_params[:name])
+      expect(alert.external_id).to eq(alert_params[:external_id])
+      expect(alert.started_at).to  be_nil
+      expect(alert.server).to      eq(server)
+
+      alert.reload
+
+      expect(alert.message).to     eq(alert_params[:message])
+      expect(alert.description).to eq(alert_params[:description])
+      expect(alert.severity).to    eq(alert_params[:severity])
+      expect(alert.name).to        eq(alert_params[:name])
+      expect(alert.external_id).to eq(alert_params[:external_id])
+      expect(alert.started_at).to  be_nil
+      expect(alert.server).to      eq(server)
+    end
+
+    it "create an alert that has been started" do
+      server = client.servers.all.first
+      alert = nil
+
+      expect {
+        alert = server.alerts.create!(alert_params.merge(started_at: Time.now))
+      }.to change { server.alerts.size }.by(1)
+
+      expect(alert.started_at).not_to be_nil
+      expect(alert.reload.started_at).not_to be_nil
+    end
+  end
+
+  context "given some alerts" do
+    let(:database_server)  { create_database_service(client: client).servers.first }
+    let(:database_server2) { create_database_service(client: client).servers.first }
+
+    let!(:alerts) {
+      [
+        client.alerts.create!(
+          :database_server => database_server,
+          :message         => Faker::Lorem.sentence(1),
+          :description     => Faker::Hacker.verb,
+          :severity        => "warning",
+          :name            => Faker::Hacker.noun,
+          :external_id     => SecureRandom.uuid,
+        ),
+        client.alerts.create!(
+          :database_server => database_server2,
+          :message         => Faker::Lorem.sentence(1),
+          :description     => Faker::Hacker.verb,
+          :severity        => "warning",
+          :name            => Faker::Hacker.noun,
+          :external_id     => SecureRandom.uuid,
+        ),
+      ]
+    }
+
+    it "should list alerts" do
+      expect(
+        client.alerts.all
+      ).to match_array(alerts)
+    end
+
+    it "should filter alerts" do
+      expect(database_server.alerts.all).to match_array(alerts[0])
+      expect(client.alerts.all(database_server: database_server.identity)).to match_array(alerts[0])
+
+      expect(database_server2.alerts.all).to match_array(alerts[1])
+      expect(client.alerts.all(database_server: database_server2.identity)).to match_array(alerts[1])
+    end
+
+    it "should update alert" do
+      alert = alerts.first
+      expect { alert.update(acknowledged: true) }.to change { alert.acknowledged }.from(false).to(true)
+      expect { alert.update(message: "something else") }.to change { alert.reload.message }
+      expect { alert.update(external_id: "new-id") }.to change { alert.reload.external_id }
+      expect { alert.update(started_at: Time.now) }.to change { alert.reload.started_at }.from(nil)
+      expect {
+        alert.update(finished_at: Time.now)
+      }.to  change { alert.reload.finished_at }.from(nil).
+        and change { database_server.alerts.all.size }.by(-1)
+    end
+  end
+end

data/spec/application_archives_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'application_archives' do
+  let(:client)       { create_client }
+  let!(:account)     { create_account(client: client) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:application) { account.applications.create!(name: "hello_servlet", type: "java") }
+
+  it "should create an application archive" do
+    archive = application.archives.create!(filename: "helloservlet.war")
+
+    # FIXME: archive.application.should == application
+    expect(archive.filename).to eq("helloservlet.war")
+    expect(archive.upload_successful).to eq(false)
+    expect(archive.upload_url).to be
+  end
+
+  context "with an archive", :mock_only do # needs uploaded archives to pass
+    let!(:archive) { application.archives.create!(filename: "helloservlet.war") }
+
+    it "should upload, mark that it was successful, and download" do
+      archive.upload(body: "enterprise")
+
+      expect(archive.upload_successful).to eq(true)
+
+      expect(archive.download.body).to eq("enterprise")
+    end
+
+    context "with multiple archives" do
+      let!(:another_application) { account.applications.create!(name: "hello_bean", type: "java") }
+      let!(:another_archive)     { another_application.archives.create!(filename: "helloservlet.war") }
+
+      it "should list based on application" do
+        expect(application.archives.all).to match_array([archive])
+        expect(another_application.archives.all).to match_array([another_archive])
+      end
+    end
+  end
+end

data/spec/applications_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe 'applications' do
+  let(:client)        { create_client }
+
+  let!(:account)     { create_account(client: client) }
+  let!(:provider)    { create_provider(account: account) }
+
+  let(:app_name)     { SecureRandom.hex(12) }
+  let(:repository)   { "#{Faker::Name.first_name}@#{Faker::Internet.domain_name}:#{app_name}/#{app_name}.git" }
+
+  it "should create an application" do
+    application = account.applications.create!(name: app_name, type: "rails3", repository: repository)
+
+    expect(application.id).not_to be_nil
+    expect(application.name).to eq(app_name)
+    expect(application.type).to eq("rails3")
+    expect(application.language).to eq("ruby")
+    expect(application.repository).to eq(repository)
+  end
+
+  it "should create a deploy keypair when creating an application" do
+    expect {
+      account.applications.create!(name: app_name, type: "rails3", repository: repository)
+    }.to change { client.keypairs.count }.by(1)
+  end
+
+  it "should list an application's keypairs" do
+    client.keypairs.create(name: "rando", public_key: SSHKey.generate.ssh_public_key) # an existing keypair
+
+    application = account.applications.create!(name: app_name, type: "rails3", repository: repository)
+
+    keypair = application.keypairs.one
+    expect(keypair.public_key).to be
+  end
+
+  it "should search for application by type" do
+    application =  client.applications.create!(name: SecureRandom.hex(12), type: "rails3", repository: repository, account: account)
+    client.applications.create!(name: SecureRandom.hex(3), type: "rails2", repository: repository, account: account)
+
+    expect(client.applications.all(type: "rails3").size).to eq(1)
+    expect(client.applications.first(type: "rails3")).to eq(application)
+  end
+
+  it "should search for application by repository" do
+    other_repository = "#{Faker::Name.first_name}@#{Faker::Internet.domain_name}:#{Faker::Name.first_name}/#{Faker::Name.last_name}.git"
+
+    application =  client.applications.create!(name: SecureRandom.hex(12), type: "rails3", repository: repository, account: account)
+    client.applications.create!(name: app_name, type: "rails3", repository: other_repository, account: account)
+
+    expect(client.applications.all(repository: repository).size).to eq(1)
+    expect(client.applications.first(repository: repository)).to eq(application)
+  end
+
+  it "has the correct language for all app types" do
+    expect(account.applications.create!(name: "merb_app", type: "merb", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rack_app", type: "rack", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rails2_app", type: "rails2", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rails3_app", type: "rails3", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "rails4_app", type: "rails4", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "sinatra_app", type: "sinatra", repository: repository).language).to eq("ruby")
+    expect(account.applications.create!(name: "php_app", type: "php", repository: repository).language).to eq("php")
+    expect(account.applications.create!(name: "nodejs_app", type: "nodejs", repository: repository).language).to eq("nodejs")
+  end
+end

data/spec/billing_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'billing', :mock_only do
+  let!(:consumer_client) { create_client }
+
+  context "with account" do
+    let!(:user)       { consumer_client.users.create!(name: Faker::Name.name, email: Faker::Internet.email) }
+    let!(:account)    { consumer_client.accounts.create!(owner: user, name_prefix: Faker::Name.first_name) }
+
+    it "has billing state" do
+      billing = consumer_client.billing.get(account.id)
+      expect(billing.state).to eq "requested"
+    end
+
+    it "can update billing state" do
+      billing = consumer_client.billing.get(account.id)
+      billing.state = "verified"
+      billing.save
+
+      billing = consumer_client.billing.get(account.id)
+      expect(billing.state).to eq "verified"
+
+      billing = consumer_client.billing.put_state(account.id, "finalized")
+      expect(billing.state).to eq "finalized"
+
+      billing = consumer_client.billing.get(account.id)
+      expect(billing.state).to eq "finalized"
+    end
+
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "client" do
+  it "recognizes the config_file parameter" do
+    tempfile = Tempfile.new('ey-core')
+    token    = SecureRandom.hex(20)
+    tempfile.write <<-EOF
+---
+'http://api-development.localdev.engineyard.com:9292/': #{token}
+    EOF
+    tempfile.rewind
+
+    client = Ey::Core::Client.new(config_file: tempfile)
+    expect(client.instance_variable_get(:@token)).to eq(token)
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "Ey::Core::Collection" do
+  let!(:client) { create_client(user: create_user) }
+
+  context "with some accounts" do
+    before(:each) { 50.times { create_account(client: client) } }
+
+    describe "#total_count" do
+      it "can get the total item count" do
+        expect(client.accounts.all.total_count).to eq(50)
+      end
+    end
+
+    describe "#first" do
+      it "can get the first item" do
+        account = client.accounts.all[1]
+
+        expect(client.accounts.first(name: account.name)).to eq(account)
+      end
+    end
+
+    describe "#each_page" do
+      it "should yield multiple pages" do
+        count = 0
+
+        client.accounts.all.each_page { |_| count += 1 }
+
+        expect(count).to eq(3)
+      end
+    end
+
+    describe "#each_entry" do
+      it "should yield multiple entries" do
+        count = 0
+
+        client.accounts.all.each_entry { |*| count += 1 }
+
+        expect(count).to eq(50)
+      end
+    end
+  end
+end