ey_services_fake 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/ey_services_fake.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ey_services_fake/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ey_services_fake"
+  s.version     = EyServicesFake::VERSION
+  s.authors     = ["Jacob Burkhart & Josh Lane"]
+  s.email       = ["jacob@engineyard.com"]
+  s.homepage    = ""
+  s.summary     = %q{A fake for use when writting tests against the ey_services_api}
+  s.description = %q{A fake for use when writting tests against the ey_services_api}
+
+  s.rubyforge_project = "ey_services_fake"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "sinatra"
+  s.add_dependency "cubbyhole", ">= 0.2.0"
+end

data/lib/ey_services_fake/mock_backend.rb

@@ -0,0 +1,151 @@
+module EyServicesFake
+  class MockBackend
+
+    def self.tresfiestas_fake
+      require 'ey_services_fake/tresfiestas_fake'
+      TresfiestasFake
+    end
+
+    def self.setup!(actors = {})
+      unless actors[:awsm]
+        require 'ey_services_fake/reacharound_awsm'
+        actors[:awsm] = ReacharoundAwsm.new
+      end
+      unless actors[:service_provider]
+        require 'ey_services_fake/mocking_bird_service'
+        actors[:service_provider] = MockingBirdService.new
+      end
+      unless actors[:tresfiestas]
+        actors[:tresfiestas] = tresfiestas_fake.new
+      end
+      new(actors)
+    end
+
+    def initialize(actors)
+      @actors = actors
+    end
+
+    def actor(role)
+      @actors[role] or raise "No actor registered as #{role}, I have #{@actors.keys.inspect}"
+    end
+
+    def reset!
+      @actors.values.each do |v|
+        v.reset!
+      end
+    end
+
+    def awsm
+      awsm_hash = actor(:tresfiestas).find_awsm
+      unless awsm_hash
+        awsm_hash = actor(:tresfiestas).create_awsm(actor(:awsm).base_url, actor(:awsm).app)
+        actor(:awsm).setup(awsm_hash[:auth_id], awsm_hash[:auth_key], actor(:tresfiestas).base_url, actor(:tresfiestas).app)
+      end
+      awsm_hash
+    end
+
+    def partner
+      partner_hash = actor(:tresfiestas).find_partner(sso_user)
+      unless partner_hash
+        partner_hash = actor(:tresfiestas).create_partner(sso_user, actor(:service_provider).base_url, actor(:service_provider).app)
+        @actors.values.each do |actor|
+          if actor.respond_to?(:service_provider_setup)
+            actor.service_provider_setup(partner_hash[:auth_id], partner_hash[:auth_key], actor(:service_provider).base_url, actor(:service_provider).app)
+          end
+        end
+        actor(:service_provider).setup(partner_hash[:auth_id], partner_hash[:auth_key], actor(:tresfiestas).base_url, actor(:tresfiestas).app)
+      end
+      partner_hash
+    end
+
+    def service
+      partner_hash = self.partner
+      service_hash = actor(:tresfiestas).find_service(partner_hash[:id])
+      unless service_hash
+        actor(:service_provider).register_service(partner_hash[:registration_url])
+        service_hash = actor(:tresfiestas).find_service(partner_hash[:id])
+      end
+      service_hash.merge(:partner => partner_hash)
+    end
+
+    def sso_user
+      actor(:awsm).sso_user #allows for nils (some implementations of AWSM may decide this is ok)
+    end
+
+    def sso_account
+      awsm #need to have setup awsm before you can create accounts!
+      sso_user_something = sso_user #the sso_user is a somehting, not necessarily a hash
+      sso_account_hash = actor(:awsm).find_sso_account(sso_user_something)
+      unless sso_account_hash
+        sso_account_hash = actor(:awsm).create_sso_account(sso_user_something)
+      end
+      sso_account_hash
+    end
+
+    def service_enablement
+      sso_account_hash = self.sso_account
+      service_hash = self.service
+      unless actor(:tresfiestas).service_available_for_account?(service_hash[:id], sso_account_hash[:id])
+        actor(:tresfiestas).make_service_available_for_account(service_hash[:id], sso_account_hash[:id])
+      end
+      {
+        :service => service_hash,
+        :sso_account => sso_account_hash,
+      }
+    end
+
+    def service_account
+      service_enablement_hash = self.service_enablement
+      sso_account_hash = service_enablement_hash[:sso_account]
+      service_hash = service_enablement_hash[:service]
+      service_account_hash = actor(:tresfiestas).find_service_account(service_hash[:id], sso_account_hash[:id])
+      unless service_account_hash
+        actor(:awsm).enable_service(service_hash[:id], sso_account_hash[:id])
+        service_account_hash = actor(:tresfiestas).find_service_account(service_hash[:id], sso_account_hash[:id])
+      end
+      service_account_hash.merge(:name => sso_account_hash[:name], :service => service_hash, :sso_account => sso_account_hash)
+    end
+
+    def destroy_service_account
+      actor(:awsm).disable_service(service_account[:id])
+    end
+
+    def app_deployment
+      app_deployment_hash = actor(:awsm).find_app_deployment(sso_account[:id])
+      unless app_deployment_hash
+        actor(:awsm).create_app_deployment(sso_account[:id], "myapp", "myenv", "production")
+        app_deployment_hash = actor(:awsm).find_app_deployment(sso_account[:id])
+      end
+      app_deployment_hash
+    end
+
+    def provisioned_service
+      service_account_hash = self.service_account
+      sso_account_hash = service_account_hash[:sso_account]
+      app_deployment_hash = self.app_deployment
+      provisioned_service_hash = actor(:tresfiestas).find_provisioned_service(service_account_hash[:id], app_deployment_hash[:id])
+      unless provisioned_service_hash
+        actor(:awsm).provision_service(sso_account_hash[:id], service_account_hash[:id], app_deployment_hash[:id])
+        provisioned_service_hash = actor(:tresfiestas).find_provisioned_service(service_account_hash[:id], app_deployment_hash[:id])
+      end
+      provisioned_service_hash.merge(:service_account => service_account_hash, :app_deployment => app_deployment_hash)
+    end
+
+    def destroy_provisioned_service
+      actor(:awsm).deprovision_service(provisioned_service[:id])
+    end
+
+    def latest_invoice
+      actor(:tresfiestas).latest_invoice
+    end
+
+    def latest_status_message
+      actor(:tresfiestas).latest_status_message
+    end
+
+    def send_message(message_url, message_type, message_subject, message_body = nil)
+      actor(:service_provider).send_message(message_url, message_type, message_subject, message_body)
+    end
+
+  end
+end

data/lib/ey_services_fake/mocking_bird_service.rb

@@ -0,0 +1,122 @@
+require 'sinatra/base'
+
+module EyServicesFake
+  class MockingBirdService
+    class Application < Sinatra::Base
+      enable :raise_errors
+      disable :dump_errors
+      disable :show_exceptions
+
+      delete '/api/1/some_provisioned_service' do
+        {}.to_json
+      end
+
+      delete '/api/1/some_service_account' do
+        {}.to_json
+      end
+
+      post '/api/1/service_accounts_callback' do
+        service_account = EY::ServicesAPI::ServiceAccountCreation.from_request(request.body.read)
+        standard_response_params = MockingBirdService.service_account_creation_params
+        EY::ServicesAPI::ServiceAccountResponse.new(
+          :provisioned_services_url => standard_response_params[:provisioned_services_url],
+          :url                      => standard_response_params[:url],
+          :configuration_url        => standard_response_params[:configuration_url],
+          :configuration_required   => standard_response_params[:configuration_required],
+          :message                  => EY::ServicesAPI::Message.new(:message_type => "status", :subject => "some messages")
+        ).to_hash.to_json
+      end
+
+      post '/api/1/provisioned_services_callback' do
+        provisioned_service = EY::ServicesAPI::ProvisionedServiceCreation.from_request(request.body.read)
+        standard_response_params = MockingBirdService.service_provisioned_params
+        EY::ServicesAPI::ProvisionedServiceResponse.new(
+          :url                    => standard_response_params[:url],
+          :vars                   => standard_response_params[:vars],
+          :configuration_required => false,
+          :configuration_url      => standard_response_params[:configuration_url],
+          :message                => EY::ServicesAPI::Message.new(:message_type => "status", :subject => "some provisioned service messages")
+        ).to_hash.to_json
+      end
+
+      get '/sso/some_service_account' do
+        "SSO Hello Service Account"
+      end
+
+      get '/sso/some_provisioned_service' do
+        "SSO Hello Provisioned Service"
+      end
+    end
+
+    def reset!
+      #no-op
+    end
+
+    def app
+      Application
+    end
+
+    def setup(auth_id, auth_key, base_url = nil, backend = nil)
+      require 'ey_services_api'
+      connection = EY::ServicesAPI.setup!(:auth_id => auth_id, :auth_key => auth_key)
+      if backend
+        connection.backend = backend
+      end
+    end
+
+    def base_url
+      self.class.base_url
+    end
+    def self.base_url
+      "http://mock.service/"
+    end
+
+    def registration_params
+      self.class.registration_params
+    end
+    def self.registration_params
+      {
+        :name => "Mocking Bird",
+        :description => "a mock service",
+        :service_accounts_url =>     "#{base_url}api/1/service_accounts_callback",
+        :home_url =>                 "#{base_url}",
+        :terms_and_conditions_url => "#{base_url}terms",
+        :vars => ["SOME_ENV_VAR", "OTHER_VAR"]
+      }
+    end
+
+    def service_account_creation_params
+      self.class.service_account_creation_params
+    end
+    def self.service_account_creation_params
+      {
+        :provisioned_services_url => "#{base_url}api/1/provisioned_services_callback",
+        :url => "#{base_url}api/1/some_service_account",
+        :configuration_url => "#{base_url}sso/some_service_account",
+        :configuration_required => false
+      }
+    end
+
+    def service_provisioned_params
+      self.class.service_provisioned_params
+    end
+    def self.service_provisioned_params
+      {
+        :vars => {"SOME_ENV_VAR" => "value", "OTHER_VAR" => "blah"},
+        :configuration_url => "#{base_url}sso/some_provisioned_service",
+        :configuration_required => false,
+        :url => "#{base_url}api/1/some_provisioned_service",
+      }
+    end
+
+    def register_service(registration_url)
+      EY::ServicesAPI.connection.register_service(registration_url, MockingBirdService.registration_params)
+    end
+
+    def send_message(message_url, message_type, message_subject, message_body)
+      message = EY::ServicesAPI::Message.new(:message_type => message_type, :subject => message_subject, :body => message_body)
+      EY::ServicesAPI.connection.send_message(message_url, message)
+    end
+
+  end
+end

data/lib/ey_services_fake/models.rb

@@ -0,0 +1,64 @@
+require 'cubbyhole/base'
+
+module EyServicesFake
+  class Model < Cubbyhole::Base
+    def self.inherited(klass)
+      decendants << klass
+    end
+    def self.nuke_all
+      decendants.map(&:nuke)
+    end
+    def self.backend
+      @backend ||= Hash.new
+    end
+    def self.decendants
+      @decendants ||= []
+    end
+    def self.belongs_to(model, name, key)
+      search_context = self.to_s.split("::")
+      search_context.pop
+      search_context = eval(search_context.join("::").to_s)
+      self.class_eval do
+        define_method(name) do
+          klass = search_context.const_get(model)
+          klass.all.find{|s| self.send(key).to_i == s.id.to_i }
+        end
+      end
+    end
+    def self.has_many(model, name, key)
+      search_context = self.to_s.split("::")
+      search_context.pop
+      search_context = eval(search_context.join("::").to_s)
+      self.class_eval do
+        define_method(name) do
+          klass = search_context.const_get(model)
+          Cubbyhole::Collection.new(klass.all.select{|s| s.send(key).to_s == self.id.to_s })
+        end
+      end
+    end
+  end
+  class Partner < Model
+    has_many :Service, :services, :partner_id
+  end
+  class Service < Model
+    has_many :ServiceEnablement, :service_enablements, :service_id
+    has_many :ServiceAccount, :service_accounts, :service_id
+    belongs_to :Partner, :partner, :partner_id
+  end
+  class ServiceAccount < Model
+    has_many :ProvisionedService, :provisioned_services, :service_account_id
+    has_many :Message, :messages, :service_account_id
+    belongs_to :Service, :service, :service_id
+  end
+  class ProvisionedService < Model
+    has_many :Message, :messages, :provisioned_service_id
+    belongs_to :ServiceAccount, :service_account, :service_account_id
+  end
+  class ServiceEnablement < Model; end
+  class Invoice < Model; end
+  class Message < Model
+    belongs_to :ServiceAccount, :service_account, :service_account_id
+    belongs_to :ProvisionedService, :provisioned_service, :provisioned_service_id
+  end
+  class Awsm < Model; end
+end

data/lib/ey_services_fake/reacharound_awsm.rb

@@ -0,0 +1,155 @@
+require 'sinatra/base'
+require 'ey_services_fake/models'
+
+module EyServicesFake
+  class ReacharoundAwsm
+    class Application < Sinatra::Base
+      enable :raise_errors
+      disable :dump_errors
+      disable :show_exceptions
+
+      post '/dashboard_notifications_url' do
+        {}.to_json
+      end
+
+    end
+
+    def app
+      Application
+    end
+
+    def reset!
+      #no-op
+    end
+
+    def base_url
+      "http://cloud.engineyard.com"
+    end
+
+    class Account < EyServicesFake::Model; end
+    class AppDeployment < EyServicesFake::Model
+      belongs_to :App, :app, :app_id
+      belongs_to :Environment, :environment, :environment_id
+    end
+    class App < EyServicesFake::Model; end
+    class Environment < EyServicesFake::Model; end
+    class User < EyServicesFake::Model
+      has_many :Account, :accounts, :owner_id
+    end
+
+    def service_provider_setup(auth_id, auth_key, service_provider_url, service_provider_rackapp)
+      @connection = EY::ApiHMAC::BaseConnection.new(auth_id, auth_key).tap{|c| c.backend = service_provider_rackapp}
+    end
+    def setup(auth_id, auth_key, tresfiestas_url, tresfiestas_rackapp)
+      #ignored... we don't talk to tresfiestas, we talk to service_provider
+    end
+
+    def sso_user
+      the_one_email = "the-one-user@example.com"
+      User.first(:email => the_one_email) || User.create(:email => the_one_email)
+    end
+
+    def find_sso_account(sso_user)
+      account = sso_user.accounts.first
+      account && {
+        :id => account.id,
+        :name => account.name,
+      }
+    end
+    def create_sso_account(sso_user)
+      Account.create(:owner_id => sso_user.id, :name => 'some-account')
+      find_sso_account(sso_user)
+    end
+
+    def find_app_deployment(sso_account_id)
+      app_deployment = AppDeployment.first(:account_id => sso_account_id)
+      app_deployment && {
+        :id => app_deployment.id,
+        :app => {
+          :name => app_deployment.app.name,
+        },
+        :environment => {
+          :name => app_deployment.environment.name,
+          :framework_env => app_deployment.environment.framework_env,
+        }
+      }
+    end
+    def create_app_deployment(sso_account_id, app_name, env_name, framework_env)
+      app = App.create(:name => app_name)
+      env = Environment.create(:name => env_name, :framework_env => framework_env)
+      AppDeployment.create(:account_id => sso_account_id, :app_id => app.id, :environment_id => env.id)
+    end
+
+    #Normal implmentations of AWSM would not be posting to service_accounts_url;
+    #they would be posting to private API to say that they wish to create a service account
+    #but this is reacharound AWSM, and so it plays the role of tresfiestas internals here
+    # def enable_service(connection, sso_account, service_hash)
+    def enable_service(service_id, sso_account_id)
+      url_gen = EyServicesFake::URL_GEN
+      service_account = ServiceAccount.create(:sso_account_id => sso_account_id, :active => false, :service_id => service_id, :dashboard_notifications_url => "#{base_url}/dashboard_notifications_url")
+      service = Service.get(service_id)
+      creation_attributes = {
+        :name           => Account.get(sso_account_id).name,
+        :url            => url_gen.partner_service_account(service, service_account),
+        :messages_url   => url_gen.messages(service, service_account),
+        :invoices_url   => url_gen.invoices(service, service_account),
+      }
+      @connection.post(service.service_accounts_url, creation_attributes) do |result, location|
+        service_account.active = true
+        service_account.provisioned_services_url = result["service_account"]['provisioned_services_url']
+        service_account.configuration_url = result["service_account"]['configuration_url']
+        service_account.url = result["service_account"]['url']
+        service_account.configuration_required = result["service_account"]['configuration_required']
+        if result["message"] && result["message"]["message_type"]
+          Message.create(
+            :service_account_id => service_account.id,
+            :message_type => result["message"]["message_type"],
+            :subject => result["message"]["subject"],
+            :body => result["message"]["body"])
+        end
+        service_account.save
+      end
+    end
+
+    def disable_service(service_account_id)
+      service_account = ServiceAccount.get(service_account_id)
+      @connection.delete(service_account.url)
+    end
+
+    def provision_service(sso_account_id, service_account_id, app_deployment_id)
+      url_gen = EyServicesFake::URL_GEN
+      provisioned_service = ProvisionedService.create(:app_deployment_id => app_deployment_id.to_i, :active => false, :service_account_id => service_account_id.to_i, :dashboard_notifications_url => "#{base_url}/dashboard_notifications_url")
+      service_account_object = ServiceAccount.get(service_account_id)
+      app_deployment = AppDeployment.get(app_deployment_id)
+      app = app_deployment.app
+      environment = app_deployment.environment
+      provision_attribtues = {
+        :url          => url_gen.partner_provisioned_service(service_account_object, provisioned_service),
+        :messages_url => url_gen.messages(service_account_object.service, service_account_object, provisioned_service),
+        :app          => {:id => app.id, :name => app.name},
+        :environment  => {:id => environment.id, :name => environment.name, :framework_env => environment.framework_env},
+      }
+      @connection.post(service_account_object.provisioned_services_url, provision_attribtues) do |result, location|
+        provisioned_service.active = true
+        provisioned_service.vars = result['provisioned_service']["vars"]
+        provisioned_service.configuration_url = result['provisioned_service']["configuration_url"]
+        provisioned_service.configuration_required = result['provisioned_service']["configuration_required"]
+        provisioned_service.url = result['provisioned_service']["url"]
+        if result["message"] && result["message"]["message_type"]
+          Message.create(
+            :provisioned_service_id => provisioned_service.id,
+            :message_type => result["message"]["message_type"],
+            :subject => result["message"]["subject"],
+            :body => result["message"]["body"])
+        end
+        provisioned_service.save
+      end
+    end
+
+    def deprovision_service(provisioned_service_id)
+      provisioned_service = ProvisionedService.get(provisioned_service_id)
+      @connection.delete(provisioned_service.url)
+    end
+
+  end
+end

data/lib/ey_services_fake/tresfiestas_fake.rb

@@ -0,0 +1,134 @@
+require 'ey_services_fake/url_generator'
+require 'ey_services_fake/models'
+require 'ey_services_fake/tresfiestas_fake_rack_app'
+
+module EyServicesFake
+  BASE_URL = "http://services.engineyard.com"
+  URL_GEN = EyServicesFake::UrlGenerator.new(BASE_URL)
+
+  class TresfiestasFake
+
+    def reset!
+      Model.nuke_all
+    end
+
+    def base_url
+      BASE_URL
+    end
+
+    def app
+      TresfiestasFakeRackApp
+    end
+
+    def find_awsm
+      awsm_object = Awsm.first
+      awsm_object && {
+        :id => awsm_object.id,
+        :auth_id => awsm_object.auth_id,
+        :auth_key => awsm_object.auth_key,
+      }
+    end
+
+    def create_awsm(awsm_base_url, awsm_app)
+      Awsm.create(:auth_id => "789eef", :auth_key => "009abb")
+      app.awsm_connection = EY::ApiHMAC::BaseConnection.new("789eef", "009abb")
+      app.awsm_connection.backend = awsm_app
+      find_awsm
+    end
+
+    def find_partner(sso_user)
+      partner_object = Partner.first
+      partner_object && {
+        :id => partner_object.id,
+        :auth_id => partner_object.auth_id,
+        :auth_key => partner_object.auth_key,
+        :registration_url => URL_GEN.service_registration(partner_object),
+      }
+    end
+
+    def create_partner(sso_user, partner_base_url, partner_app)
+      Partner.create(:auth_id => "123edf", :auth_key => "abc456")
+      app.partner_connection = EY::ApiHMAC::BaseConnection.new("123edf", "abc456")
+      app.partner_connection.backend = partner_app
+      find_partner(sso_user)
+    end
+
+    def find_service(partner_id)
+      partner_object = Partner.get!(partner_id)
+      service_object = partner_object.services.first
+      service_object && {
+        :id => service_object.id,
+        :name => service_object.name,
+        :service_accounts_url => service_object.service_accounts_url
+      }
+    end
+
+    def service_available_for_account?(service_id, sso_account_id)
+      Service.get(service_id).service_enablements.first(:sso_account_id => sso_account_id)
+    end
+
+    def make_service_available_for_account(service_id, sso_account_id)
+      ServiceEnablement.create(:service_id => service_id.to_i, :sso_account_id => sso_account_id.to_i, :reason => "test")
+    end
+
+    def find_service_account(service_id, sso_account_id)
+      service_object = Service.get(service_id)
+      service_account_object = service_object.service_accounts.first(:sso_account_id => sso_account_id)
+      service_account_object && {
+        :id             => service_account_object.id,
+        :url            => URL_GEN.partner_service_account(service_object, service_account_object),
+        :messages_url   => URL_GEN.messages(service_object, service_account_object),
+        :invoices_url   => URL_GEN.invoices(service_object, service_account_object),
+        :pushed_service_account => {
+          :provisioned_services_url => service_account_object.provisioned_services_url,
+          :configuration_url => service_account_object.configuration_url,
+          :url => service_account_object.url,
+          :configuration_required => service_account_object.configuration_required,
+        }
+      }
+    end
+
+    def find_provisioned_service(service_account_id, app_deployment_id)
+      service_account = ServiceAccount.get(service_account_id)
+      provisioned_service = service_account.provisioned_services.first(:app_deployment_id => app_deployment_id)
+      provisioned_service && {
+        :id => provisioned_service.id,
+        :url => URL_GEN.partner_provisioned_service(service_account, provisioned_service),
+        :messages_url => URL_GEN.messages(service_account.service, service_account, provisioned_service),
+        :pushed_provisioned_service => {
+          :vars => provisioned_service.vars,
+          :configuration_url => provisioned_service.configuration_url,
+          :configuration_required => provisioned_service.configuration_required,
+          :url => provisioned_service.url
+        }
+      }
+    end
+
+    def latest_invoice
+      invoice = Invoice.last
+      {
+        :total_amount_cents  => invoice.total_amount_cents,
+        :line_item_description => invoice.line_item_description,
+        :service_account_id => invoice.service_account_id,
+      }
+    end
+
+    def latest_status_message
+      if message = Message.last(:message_type => "status")
+        to_return = {
+          :id => message.id,
+          :subject => message.subject,
+          :body => message.body
+        }
+        if message.respond_to?(:service_account) && message.service_account
+          to_return[:service_account_id] = message.service_account.id
+        end
+        if message.respond_to?(:provisioned_service) && message.provisioned_service
+          to_return[:provisioned_service_id] = message.provisioned_service.id
+        end
+        to_return
+      end
+    end
+
+  end
+end

data/lib/ey_services_fake/tresfiestas_fake_rack_app.rb

@@ -0,0 +1,156 @@
+require 'sinatra/base'
+
+module EyServicesFake
+  class TresfiestasFakeRackApp < Sinatra::Base
+    enable :raise_errors
+    disable :dump_errors
+    disable :show_exceptions
+
+    class << self
+      attr_accessor :partner_connection
+      attr_accessor :awsm_connection
+    end
+
+    ################
+    # External API #
+    ################
+
+    get '/api/1/partners/:partner_id/services' do |partner_id|
+      partner = Partner.get!(partner_id)
+      to_return = []
+      partner.services.each do |service|
+        to_return << {"service" => service.attributes.merge('url' => URL_GEN.service(service)) }
+      end
+      to_return.to_json
+    end
+
+    #TODO: auth!
+    post '/api/1/partners/:partner_id/services' do |partner_id|
+      partner = Partner.get!(partner_id)
+      service_json = JSON.parse(request.body.read)["service"]
+      if service_json["name"].to_s.empty?
+        status 400
+        {:error_messages => ["Name can't be blank"]}.to_json
+      else
+        service = Service.create(service_json.merge(:partner_id => partner.id))
+        status 201
+        headers 'Location' => URL_GEN.service(service)
+        {}.to_json
+      end
+    end
+
+    get '/api/1/partners/:partner_id/services/:service_id' do |partner_id, service_id|
+      partner = Partner.get!(partner_id)
+      if service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+        {"service" => service.attributes}.to_json
+      else
+        status 404
+        {}.to_json
+      end
+    end
+
+    put '/api/1/partners/:partner_id/services/:service_id' do |partner_id, service_id|
+      partner = Partner.get!(partner_id)
+      service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+      update_params = JSON.parse(request.body.read)["service"]
+      if update_params.key?("name") && update_params["name"].to_s.empty?
+        status 400
+        {:error_messages => ["Name can't be blank"]}.to_json
+      else
+        service.update_attributes(update_params)
+        {}.to_json
+      end
+    end
+
+    delete '/api/1/partners/:partner_id/services/:service_id' do |partner_id, service_id|
+      partner = Partner.get!(partner_id)
+      service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+      service.destroy
+      {}.to_json
+    end
+
+    put '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id' do |partner_id, service_id, service_account_id|
+      partner = Partner.get!(partner_id)
+      service = partner.services.detect{ |s| s.id.to_s == service_id.to_s }
+      service_account = service.service_accounts.detect{ |sa| sa.id.to_s == service_account_id.to_s }
+      service_account_atts = JSON.parse(request.body.read)["service_account"]
+      service_account.update_attributes(service_account_atts)
+      {}.to_json
+    end
+
+    post '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id/invoices' do |partner_id, service_id, service_account_id|
+      invoice_params = JSON.parse(request.body.read)["invoice"]
+      unless invoice_params['total_amount_cents'].is_a?(Fixnum)
+        status 400
+        return {:error_messages => ["Total Amount Cents must be an integer"]}.to_json
+      end
+      if invoice_params["line_item_description"].to_s.empty?
+        status 400
+        return {:error_messages => ["Line item description can't be blank"]}.to_json
+      end
+      if invoice_params['total_amount_cents'] < 0
+        status 400
+        return {:error_messages => ["Total amount cents must be greater than or equal to 0"]}.to_json
+      end
+      Invoice.create(invoice_params.merge(:service_account_id => service_account_id.to_i))
+      {}.to_json
+    end
+
+    post '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id/messages' do |partner_id, service_id, service_account_id|
+      message_params = JSON.parse(request.body.read)["message"]
+      message_type = message_params['message_type']
+      subject = message_params['subject']
+      body = message_params['body']
+      
+      if subject.to_s.empty?
+        status 400
+        return {:error_messages => ["Subject can't be blank."]}.to_json
+      end
+
+      unless ['status', 'notification', 'alert'].include? message_type
+        status 400
+        return {:error_messages => ['Message type must be one of: status, notification or alert']}.to_json
+      end
+
+      service_account = ServiceAccount.get(service_account_id)
+      message = Message.create(message_params.merge(:service_account_id => service_account.id))
+      self.class.awsm_connection.post(service_account.dashboard_notifications_url, {
+        :notification => {:subject => subject, :body => body},
+        :message_type => message_type,
+        :configuration_possible => !!service_account.configuration_url,
+        :service_name => service_account.service.name,
+        :service_id => service_account.service_id})
+      {}.to_json
+    end
+
+    post '/api/1/partners/:partner_id/services/:service_id/service_accounts/:service_account_id/provisioned_service/:provisioned_service_id/messages' do |partner_id, service_id, service_account_id, provisioned_service_id|
+      message_params = JSON.parse(request.body.read)["message"]
+      subject = message_params['subject']
+      message_type = message_params['message_type']
+      body = message_params['body']
+
+      if subject.to_s.empty?
+        status 400
+        return {:error_messages => ["Subject can't be blank."]}.to_json
+      end
+
+      unless ['status', 'notification', 'alert'].include? message_type
+        status 400
+        return {:error_messages => ['Message type must be one of: status, notification or alert']}.to_json
+      end
+
+      message = Message.create(message_params.merge(:provisioned_service_id => provisioned_service_id.to_i))
+      provisioned_service = ProvisionedService.get(provisioned_service_id)
+      service_account = provisioned_service.service_account
+      message = Message.create(message_params.merge(:provisioned_service_id => provisioned_service.id))
+      self.class.awsm_connection.post(provisioned_service.dashboard_notifications_url, {
+        :notification => {:subject => subject, :body => body},
+        :message_type => message_type,
+        :configuration_possible => !!provisioned_service.configuration_url,
+        :service_name => service_account.service.name,
+        :provisionable_service_id => provisioned_service.id})
+      {}.to_json
+    end
+
+  end
+end

data/lib/ey_services_fake/url_generator.rb

@@ -0,0 +1,37 @@
+module EyServicesFake
+  class UrlGenerator
+
+    def initialize(base_url)
+      @base_url = base_url
+    end
+
+    def service_registration(partner)
+      "#{@base_url}/api/1/partners/#{partner.id}/services"
+    end
+
+    def service(service)
+      "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}"
+    end
+
+    def partner_service_account(service, service_account)
+      "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}"
+    end
+
+    def messages(service, service_account, provisioned_service = nil)
+      if provisioned_service
+        "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}/provisioned_service/#{provisioned_service.id}/messages"
+      else
+        "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}/messages"
+      end
+    end
+
+    def invoices(service, service_account)
+      "#{@base_url}/api/1/partners/#{service.partner_id}/services/#{service.id}/service_accounts/#{service_account.id}/invoices"
+    end
+
+    def partner_provisioned_service(service_account, provisioned_service)
+      "#{@base_url}/api/1/service_accounts/#{service_account.id}/provisioned_service/#{provisioned_service.id}"
+    end
+
+  end
+end

data/lib/ey_services_fake/version.rb

@@ -0,0 +1,3 @@
+module EyServicesFake
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: ey_services_fake
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jacob Burkhart & Josh Lane
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cubbyhole
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id002
+description: A fake for use when writting tests against the ey_services_api
+email: 
+- jacob@engineyard.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- ey_services_fake.gemspec
+- lib/ey_services_fake/mock_backend.rb
+- lib/ey_services_fake/mocking_bird_service.rb
+- lib/ey_services_fake/models.rb
+- lib/ey_services_fake/reacharound_awsm.rb
+- lib/ey_services_fake/tresfiestas_fake.rb
+- lib/ey_services_fake/tresfiestas_fake_rack_app.rb
+- lib/ey_services_fake/url_generator.rb
+- lib/ey_services_fake/version.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ey_services_fake
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A fake for use when writting tests against the ey_services_api
+test_files: []
+