groove-ey-core 3.6.1

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/auto_scaling_alarms_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+RSpec.describe "Auto scaling alarms" do
+  let!(:client) { create_client }
+  let!(:account) { create_account(client: client) }
+  let(:policy) { create_auto_scaling_policy }
+
+  let(:params) do
+    {
+      "name" => SecureRandom.hex(16),
+      "aggregation_type" => "avg",
+      "metric_type" => "cpu",
+      "operand" => "gt",
+      "trigger_value" => 0.5,
+      "number_of_periods" => 1,
+      "period_length" => 30,
+      "auto_scaling_policy_id" => policy.id
+    }
+  end
+
+  let!(:alarm) { client.auto_scaling_alarms.create!(params).resource! }
+
+  it "creates a new alarm for an auto scaling policy" do
+    expect(alarm).not_to be_nil
+    expect(policy.auto_scaling_alarms).not_to be_empty
+    expect(client.auto_scaling_alarms).not_to be_empty
+  end
+
+  it "updates an alarm" do
+    expect do
+      alarm.update("name" => "new name")
+    end.to change { alarm.name }.to("new name")
+  end
+
+  it "destroys auto scalig alarm by it's id" do
+    expect do
+      alarm.destroy!
+    end.to change { policy.reload.auto_scaling_alarms.count }.from(1).to(0)
+  end
+end

data/spec/auto_scaling_groups_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client) { create_client }
+
+  context "with an environment" do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:app)         { create_application(account: account, client: client) }
+    let!(:environment) { create_environment(client: client, account: account, application: app, configuration: { type: "production"}) }
+
+    it "adds an auto scaling group" do
+      expect {
+        client.auto_scaling_groups.create!(minimum_size: 2, maximum_size: 6, environment: environment).resource!
+      }.to change { environment.reload.auto_scaling_group }.from(nil).and change { client.auto_scaling_groups.count }.by(1)
+    end
+
+    context "with an auto scaling group" do
+      let!(:group) { client.auto_scaling_groups.create!(minimum_size: 2, maximum_size: 6, environment: environment).resource! }
+
+      it "destroys the auto scaling group" do
+        expect {
+          group.destroy.ready!
+        }.to change { group.reload.deleted_at }.from(nil).and change { client.environments.get(environment.id).auto_scaling_group }.to(nil)
+      end
+    end
+  end
+end

data/spec/auto_scaling_policies_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+RSpec.describe "Auto scaling policies" do
+  let!(:client) { create_client }
+  let!(:account) { create_account(client: client) }
+  let!(:environment) { create_environment(account: account) }
+  let(:auto_scaling_group) { create_auto_scaling_group(environment: environment.id) }
+  let(:simple_policy_params) do
+    {
+      name: SecureRandom.hex(16),
+      action_value: 2,
+      action_type: "add",
+      action_unit: "instances",
+      auto_scaling_group_id: auto_scaling_group.id,
+      type: "simple"
+    }
+  end
+
+  describe "common requests for all policy types" do
+    let!(:policy) { client.auto_scaling_policies.create!(simple_policy_params).resource! }
+
+    it "is able to retrieve auto scaling policy by it's id" do
+      found_policy = client.auto_scaling_policies.get(policy.id)
+      expect(found_policy).not_to be_nil
+      expect(found_policy.id).to eq(policy.id)
+    end
+
+    it "updates auto scaling policy" do
+      expect do
+        policy.update(name: "new name")
+      end.to change { policy.name }.to("new name")
+    end
+
+    it "destroys a policy by it's id" do
+      expect do
+        policy.destroy!
+      end.to change { auto_scaling_group.reload.simple_auto_scaling_policies.count }.from(1).to(0)
+    end
+  end
+
+  context "simple autoscaling policy" do
+    it "adds one to autoscaling group" do
+      expect {
+        client.auto_scaling_policies.create!(simple_policy_params)
+      }.to change { auto_scaling_group.reload.simple_auto_scaling_policies.count }.from(0).to(1)
+        .and not_change { auto_scaling_group.reload.step_auto_scaling_policies.count }
+        .and not_change { auto_scaling_group.reload.target_auto_scaling_policies.count }
+    end
+  end
+
+  context "target tracking auto scaling policy" do
+    let(:params) do
+      {
+        auto_scaling_group_id: auto_scaling_group.id,
+        name: SecureRandom.hex(16),
+        target_value: 0.7,
+        estimated_warmup: 200,
+        metric_type: "avg_cup",
+        disable_scale_in: false,
+        type: "target"
+      }
+    end
+
+    it "adds one to autoscaling group" do
+      expect {
+        client.auto_scaling_policies.create!(params)
+      }.to change { auto_scaling_group.reload.target_auto_scaling_policies.count }.from(0).to(1)
+        .and not_change { auto_scaling_group.reload.simple_auto_scaling_policies.count }
+        .and not_change { auto_scaling_group.reload.step_auto_scaling_policies.count }
+    end
+  end
+
+  context "step auto scaling policy" do
+    let(:params) do
+      {
+        auto_scaling_group_id: auto_scaling_group.id,
+        name:                  SecureRandom.hex(16),
+        estimated_warmup:      200,
+        action_unit:           "instances",
+        action_type:           "add",
+        steps:                 [{ metric_from: 50, metric_to: nil, action_value: 1 }],
+        type:                  "step"
+      }
+    end
+
+    it "adds one to autoscaling group" do
+      expect {
+        client.auto_scaling_policies.create!(params)
+      }.to change { auto_scaling_group.reload.step_auto_scaling_policies.count }.from(0).to(1)
+        .and not_change { auto_scaling_group.reload.simple_auto_scaling_policies.count }
+        .and not_change { auto_scaling_group.reload.target_auto_scaling_policies.count }
+    end
+  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/blueprints_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client) { create_client }
+
+  context "with a blueprint" do
+    let!(:account)     { create_account(client: client) }
+    let!(:provider)    { create_provider(account: account) }
+    let!(:app)         { create_application(account: account, client: client) }
+    let!(:environment) { create_environment(account: account, app: app, environment: { name: SecureRandom.hex(3)}, configuration: { type: "production"}) }
+    let!(:blueprint)   { environment.save_blueprint("name" => SecureRandom.hex(3)) }
+
+    it "changes the name" do
+      name = SecureRandom.hex(4)
+      expect {
+        blueprint.update(name: name)
+      }.to change { blueprint.reload.name }.to(name)
+    end
+
+    it "deletes the blueprint" do
+      expect {
+        blueprint.destroy
+      }.to change { blueprint.reload }.to(nil)
+    end
+
+    it "boots an environment from a blueprint" do
+      new_environment = create_environment(account: account, app: app, environment: {name: SecureRandom.hex(5)}, boot: false)
+
+      expect {
+        new_environment.boot("blueprint_id" => blueprint.id)
+      }.to change { new_environment.servers.count }.to(5)
+    end
+
+    it "boots an environment from a blueprint with an IP Address" do
+      address = client.addresses.create!(provider: provider, location: "us-west-2").resource!
+      new_environment = create_environment(account: account, app: app, environment: {name: SecureRandom.hex(5)}, boot: false)
+
+      expect {
+        new_environment.boot("blueprint_id" => blueprint.id, "ip_id" => address.id)
+      }.to change { new_environment.servers.count }.to(5)
+
+      app_master = new_environment.servers.detect{|s| s.role == "app_master"}
+      expect(app_master.address).to eq address
+    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

data/spec/costs_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Costs' do
+  let(:client)   { create_client }
+  let!(:account) { create_account(client: client) }
+
+  it 'should return an empty array with no costs' do
+    expect(account.costs.all).to be_empty
+  end
+
+  it 'should get costs for an account', :mock_only do
+    create_cost(client, account: account)
+    expect(account.costs.all).not_to be_empty
+  end
+
+  it 'should search costs', :mock_only do
+    create_cost(client, account: account, level: 'total')
+    create_cost(client, account: account, level: 'summarized')
+    costs = account.costs.select { |c| c.level == 'total' }
+    expect(costs.first.level).to eq 'total'
+  end
+end

data/spec/database_plan_usage_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe "plan_usage", :mock_only do
+  let!(:client)  { create_client }
+  let!(:account) { create_account(client: client, account: { owner: create_user(client: client)}) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:database_service)    { create_database_service(provider: provider) }
+
+  before(:each) do
+    client.find(:database_plan_usages, account.id).merge!(
+      "2014-07" => [
+        {
+          "start_at"      => "2014-05-01T00:00:00+00:00",
+          "end_at"        => "2014-05-31T23:59:59+00:00",
+          "report_time"   => Time.now.iso8601,
+          "type"          => "self-service-00",
+          "database_service" => "https://api.engineyard.com/database_services/#{database_service.id}",
+        },
+      ]
+    )
+  end
+
+  it "can fetch plan usage for an account and billing_month" do
+    database_plan_usages = client.database_plan_usages.all(account_id: account.id, billing_month: "2014-07")
+
+    expect(database_plan_usages.size).to eq(1)
+
+    database_plan_usage = database_plan_usages.first
+
+    expect(database_plan_usage.start_at).not_to be_nil
+    expect(database_plan_usage.end_at).not_to be_nil
+    expect(database_plan_usage.report_time).not_to be_nil
+
+    expect(database_plan_usage.type).to eq("self-service-00")
+
+    expect(database_plan_usage.database_service).to eq(database_service)
+  end
+
+end