fastly 0.5

data/lib/fastly/vcl.rb

@@ -0,0 +1,28 @@
+class Fastly
+  # An internal representation of a Varnish Configuration Language file
+  class VCL < BelongsToServiceAndVersion
+    attr_accessor :service_id, :name, :content, :comment
+    ## 
+    # :attr: service_id
+    # 
+    # The id of the service this belongs to.
+    # 
+
+    ## 
+    # :attr: version
+    # 
+    # The number of the version this belongs to.
+    # 
+
+    ## 
+    # :attr: content
+    # 
+    # The content of this VCL
+    # 
+
+    ## 
+    # :attr: comment 
+    # 
+    # a free form comment field
+  end
+end

data/lib/fastly/version.rb

@@ -0,0 +1,148 @@
+class Fastly
+  # An iteration of your configuration
+  class Version < Base
+    attr_accessor :service_id, :number, :name, :active, :locked, :staging, :testing, :deployed, :comment
+    
+    ## 
+    # :attr: service_id
+    # The id of the service this belongs to.
+
+    ##
+    # :attr: number
+    # The generation of this version
+
+    ## 
+    # :attr: name
+    # 
+    # The name of this version.
+  
+
+    ## 
+    # :attr: active
+    # 
+    # Whether this version is active or not.
+    
+
+    ## 
+    # :attr: locked
+    # 
+    # Whether this version is locked or not.
+    
+
+    ## 
+    # :attr: staging
+    # 
+    # Whether this version is in staging or not.
+     
+
+    ## 
+    # :attr: testing
+    # 
+    # Whether this version is in testing or not.
+    # 
+
+    ## 
+    # :attr: deployed
+    # 
+    # Whether this version is deployed or not.
+    # 
+
+    ## 
+    # :attr: comment 
+    #
+    # a free form comment field
+    
+    
+    # Get the Service object this Version belongs to
+    def service 
+      fetcher.get(Fastly::Service, service_id)
+    end
+
+    # Get the Settings object for this Version
+    def settings
+      fetcher.get_settings(service_id, number)
+    end
+
+    # Activate this version
+    def activate!
+      raise Fastly::FullAuthRequired unless fetcher.fully_authed?
+      hash = fetcher.client.put(Fastly::Version.put_path(self)+"/activate")
+      return !hash.nil?
+    end
+
+    # XXX Not currently
+    # def deactivate!
+    #    raise Fastly::FullAuthRequired unless fetcher.fully_authed?
+    #    hash = fetcher.client.put(Fastly::Version.put_path(self)+"/deactivate")
+    #    return !hash.nil?
+    # end
+
+    # Clone this Version
+    def clone
+      raise Fastly::FullAuthRequired unless fetcher.fully_authed?
+      hash = fetcher.client.put(Fastly::Version.put_path(self)+"/clone")
+      return nil if hash.nil?
+      return Fastly::Version.new(hash, fetcher)
+    end
+
+    # Get the generated VCL object for this Version (which must have been activated first)
+    #
+    # Won't return the content of the VCL unless you pass in 
+    #    :include_content => true
+    # in the opts
+    def generated_vcl(opts={})
+      raise Fastly::FullAuthRequired unless fetcher.fully_authed?
+      hash = fetcher.client.get(Fastly::Version.put_path(self)+"/generated_vcl", opts)
+      opts = {
+        'content'    => hash['vcl'] || hash['content'],
+        'name'       => hash['md5'],
+        'version'    => hash['version'],
+        'service_id' => hash['service']     
+      }
+      return Fastly::VCL.new(opts, fetcher)
+    end
+
+    # Upload a VCL file for this Version
+    def upload_vcl(name, content)
+      raise Fastly::FullAuthRequired unless fetcher.fully_authed?
+      hash = fetcher.client.post(Fastly::Version.put_path(self)+"/vcl", :name => name, :content => content)
+      return nil if hash.nil?
+      return Fastly::VCL.new(hash, fetcher)
+    end
+
+    # Get the named VCL for this version
+    #
+    # Won't return the content of the VCL unless you pass in 
+    #    :include_content => true
+    # in the opts
+    def vcl(name, opts={})
+      raise Fastly::FullAuthRequired unless fetcher.fully_authed?
+      fetcher.get_vcl(service_id, number, name, opts)
+    end
+
+    # Validate this Version
+    def validate
+      raise Fastly::FullAuthRequired unless fetcher.fully_authed?
+      hash = fetcher.client.get(Fastly::Version.put_path(self)+"/validate")
+      return !hash.nil?
+    end
+    
+    private
+    
+    def self.get_path(service, number)
+      "/service/#{service}/version/#{number}"
+    end
+
+    def self.post_path(opts)
+      "/service/#{opts[:service_id]}/version"
+    end
+
+    def self.put_path(obj)
+      get_path(obj.service_id, obj.number)
+    end
+
+    def self.delete_path(obj)
+      put_path(obj)
+    end
+  end 
+end

data/test/admin_test.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby 
+
+require 'rubygems'
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class AdminTest < Test::Unit::TestCase
+  def setup
+    opts = login_opts(:full).merge(:use_curb => false)
+    begin
+      @client = Fastly::Client.new(opts)
+      @fastly = Fastly.new(opts)
+    rescue Exception => e
+      warn e.inspect
+      warn e.backtrace.join("\n")
+      exit(-1)
+    end
+  end
+  
+  def test_creating_and_updating_customer
+    return unless @fastly.current_user.can_do?(:admin)
+    customer = @fastly.create_customer(:name => "fastly-ruby-test-customer-#{get_rand}")
+    email    = "fastly-ruby-test-#{get_rand}-new@example.com"
+    user     = @fastly.create_user(:login => email, :name => "New User")
+    customer.owner_id = user.id
+    
+    tmp = @fastly.update_customer(customer)
+    assert tmp
+    assert_equal customer.id, tmp.id
+    assert_equal customer.owner.id, tmp.owner.id
+  end
+  
+  def test_creating_and_updating_customer_with_owner
+    return unless @fastly.current_user.can_do?(:admin)
+    email    = "fastly-ruby-test-#{get_rand}-new@example.com"
+    customer = @fastly.create_customer(:name => "fastly-ruby-test-customer-#{get_rand}", :owner => { :login => email, :name => "Test NewOwner" })
+    assert customer
+    assert_equal customer.owner.login, email
+  end
+  
+end

data/test/api_key_test.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby 
+require 'rubygems'
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class ApiKeyTest < Test::Unit::TestCase
+  include CommonTests
+  
+  def setup
+    @opts = login_opts(:api_key)
+    begin
+      @client = Fastly::Client.new(@opts)
+      @fastly = Fastly.new(@opts)
+    rescue Exception => e
+      pp e
+      exit(-1)
+    end
+  end
+  
+  def test_raw_client
+    user = customer = nil
+    assert_raise(Fastly::Error) {
+      user     = @client.get('/current_user')
+    }
+    assert_equal nil, user    
+    assert_raise(Fastly::Error) {
+      customer = @client.get('/current_customer')
+    }
+    assert_equal nil, customer
+  end
+  
+  
+  def test_current_user_and_customer 
+    current_user  = current_customer = nil
+    assert_raise(Fastly::Error) {
+      current_user = @fastly.current_user
+    }
+    assert_equal nil, current_user
+
+    assert_raise(Fastly::Error) {
+      current_customer = @fastly.current_customer
+    }
+    assert_equal nil, current_customer    
+  end 
+  
+  
+  def test_purging
+    #assert @fastly.purge('foo')
+    # TODO Won't work until we get fixtures in Heavenly
+    #assert @fastly.purge_all('foo')
+  end
+end

data/test/common.rb

@@ -0,0 +1,155 @@
+module CommonTests
+  def test_creating_service_and_backend
+    name        = "fastly-test-service-#{get_rand}"
+    service     = @fastly.create_service(:name => name)
+    assert service
+    assert_equal name, service.name
+    tmp         = @fastly.get_service(service.id)
+    assert tmp
+    assert_equal name, tmp.name
+
+    version     = service.version
+    assert version
+
+    settings    = @fastly.get_settings(service.id, version.number)
+    assert settings
+    assert_equal settings.service_id, service.id
+    assert_equal settings.version, version.number
+
+    default_ttl = settings.settings['general.default_ttl']
+    settings    = version.settings
+    assert settings
+    assert_equal settings.service_id, service.id
+    assert_equal settings.version, version.number
+    assert_equal settings.settings['general.default_ttl'], default_ttl
+    
+    settings.settings['general.default_ttl'] = default_ttl = "888888888"
+    settings.save!;
+
+    settings = version.settings
+    assert_equal settings.settings['general.default_ttl'], default_ttl;
+    
+    services = @fastly.list_services
+    assert !services.empty?
+    assert !services.select { |s| s.name == name }.empty?
+    
+    service = @fastly.search_services( :name => name )
+    assert service
+    assert name, service.name
+    
+    
+    service = @fastly.search_services( :name => name, :version => version.number )
+    assert services
+    assert name, service.name
+    
+    version2    = @fastly.create_version(:service_id => service.id)
+    assert version2
+    assert_equal = version.number.to_i+1, version2.number.to_i 
+    
+    version3 = version2.clone
+    assert version3
+    assert_equal = version2.number.to_i+1, version3.number.to_i 
+    
+    number = version3.number.to_i
+    
+    backend_name = "fastly-test-backend-#{get_rand}"
+    backend = begin 
+      @fastly.create_backend(:service_id => service.id, :version => number, :hostname => 'localhost', :name => backend_name) 
+    rescue Fastly::Error 
+    end
+    assert_nil backend
+    
+    backend = @fastly.create_backend(:service_id => service.id, :version => number, :address => '74.125.224.146', :name => backend_name)
+    assert backend
+    assert_equal backend.service_id, service.id
+    assert_equal backend.ipv4, '74.125.224.146'
+    assert_equal backend.address, '74.125.224.146'
+    assert_equal backend.port, '80'
+    
+    backend.hostname = 'thegestalt.org'
+    backend.port     = '9092'
+    @fastly.update_backend(backend)
+    backend          = @fastly.get_backend(service.id, number, backend_name)
+    
+    assert backend
+    assert_equal backend.address, 'thegestalt.org'
+    assert_equal backend.hostname, 'thegestalt.org'
+    assert_equal backend.port, '9092'
+    
+    
+    domain_name = "fastly-test-domain-#{get_rand}-example.com"
+    domain  = @fastly.create_domain(:service_id => service.id, :version => number, :name => domain_name)
+    assert domain
+    assert_equal domain_name, domain.name
+    assert_equal domain.service.id, service.id
+    assert_equal domain.version_number.to_s, number.to_s
+    assert_equal domain.version.number.to_s, number.to_s
+    
+    domain.comment = "Flibbety gibbet"
+    domain.save!
+    domain         = @fastly.get_domain(service.id, number, domain_name)
+    assert_equal domain.name, domain_name
+    assert_equal domain.comment, "Flibbety gibbet"
+    
+    director_name = "fastly-test-director-#{get_rand}"
+    director      = @fastly.create_director(:service_id => service.id, :version => number, :name => director_name)
+    assert director
+    assert_equal director_name, director.name
+    assert_equal director.service.id, service.id
+    assert_equal director.version_number.to_s, number.to_s
+    assert_equal director.version.number.to_s, number.to_s
+    
+    origin_name = "fastly-test-origin-#{get_rand}"
+    origin      = @fastly.create_origin(:service_id => service.id, :version => number, :name => origin_name)
+    assert origin
+    assert_equal origin_name, origin.name
+    assert_equal origin.service.id, service.id
+    assert_equal origin.version_number.to_s, number.to_s
+    # assert_equal origin.version.number.to_s, number.to_s
+    
+    assert version3.activate!
+    
+    generated = version3.generated_vcl
+    assert generated
+    assert generated.content.nil?
+    generated = version3.generated_vcl(:include_content => true)
+    assert !generated.content.nil?
+    assert generated.content.match(/\.port = "9092"/ms)
+    
+    assert version3.validate
+
+    #assert @fastly.deactivate_version(version2)
+  end
+
+  def test_stats
+    name        = "fastly-test-service-#{get_rand}"
+    service     = @fastly.create_service(:name => name)
+    assert service
+    assert_equal name, service.name
+    tmp         = @fastly.get_service(service.id)
+    assert tmp
+    assert_equal name, tmp.name
+
+    stats       = service.stats
+    assert stats
+  end
+  
+  def test_invoices
+    name        = "fastly-test-service-#{get_rand}"
+    service     = @fastly.create_service(:name => name)
+    assert service
+    assert_equal name, service.name
+
+    invoice     = service.invoice
+    assert invoice
+    assert invoice.regions
+    assert_equal invoice.service_id, service.id
+        
+    invoices    = @fastly.list_invoices
+    services    = @fastly.list_services
+    assert_equal invoices.size, services.size
+    assert_equal Fastly::Invoice, invoices[0].class
+    assert       invoices[0].service_id
+  end
+
+end

data/test/full_login_test.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby 
+
+require 'rubygems'
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class FullLoginTest < Test::Unit::TestCase
+  include CommonTests
+  
+  def setup
+    @opts = login_opts(:full).merge(:use_curb => false)
+    begin
+      @client = Fastly::Client.new(@opts)
+      @fastly = Fastly.new(@opts)
+    rescue Exception => e
+      warn e.inspect
+      warn e.backtrace.join("\n")
+      exit(-1)
+    end
+  end
+  
+  def test_raw_client
+    user     = @client.get('/current_user')
+    assert user
+    assert_equal @opts[:user], user['login']
+    assert_equal @opts[:name], user['name']
+
+    customer = @client.get('/current_customer')
+    assert customer
+    assert_equal @opts[:customer], customer['name']
+  end
+  
+  
+  def test_current_user_and_customer
+    user     = @fastly.current_user
+    assert user
+    assert_equal @opts[:user], user.login
+    assert_equal @opts[:name], user.name
+
+    customer = @fastly.current_customer
+    assert customer
+    assert_equal @opts[:customer], customer.name
+    
+    tmp_customer = user.customer
+    assert_equal customer.id, tmp_customer.id
+    
+    tmp_user = customer.owner
+    assert_equal user.id, tmp_user.id
+  end
+  
+  
+  def test_fetching_particular_user
+    current_user = @fastly.current_user
+    assert current_user
+    
+    id_user = @fastly.get_user(current_user.id)
+    assert_equal current_user.id, id_user.id
+    assert_equal current_user.name, id_user.name
+    
+    # FIXME looking up by login doesn't work yet
+    #login_user = @fastly.get_user(current_user.login)
+    #assert_equal current_user.id, login_user.id
+    #assert_equal current_user.name, login_user.name  
+
+    current_customer = @fastly.current_customer
+    assert current_customer
+
+    customer = @fastly.get_customer(current_customer.id)
+    assert_equal current_customer.id, customer.id
+    assert_equal current_customer.name, customer.name
+  end
+
+  def test_creating_and_updating_user
+    customer = @fastly.current_customer
+    email    = "fastly-ruby-test-#{get_rand}-new@example.com"
+    user     = @fastly.create_user(:login => email, :name => "New User")
+    assert user
+    assert_equal customer.id, user.customer_id
+    assert_equal "New User", user.name 
+    assert_equal email, user.login
+
+    tmp       = @fastly.get_user(user.id)
+
+    assert tmp
+    assert_equal user.id, tmp.id
+    assert_equal user.name, tmp.name
+    
+    user.name = "Updated Name"
+    tmp      = @fastly.update_user(user) 
+    assert tmp
+    assert_equal user.id, tmp.id
+    assert_equal "Updated Name", tmp.name
+    
+    assert @fastly.delete_user(user)
+    tmp       = @fastly.get_user(user.id)
+    assert_equal nil, tmp
+  end
+end