stormforge-ruby 0.5.0

data/lib/thor/storm_forge_base.rb

@@ -0,0 +1,46 @@
+class StormForge::Thor::Base < Thor
+  private
+
+  def client
+    error "WARNING! Disabling SSL certificate verification is not recommended. Proceed with caution!" if options[:skip_ssl_verify]
+
+    @client ||= StormForge::Client.new({
+      user: authentication["email"],
+      token: authentication["authentication_token"],
+      dev_mode: dev_mode?,
+      skip_ssl_verify: options[:skip_ssl_verify]
+    })
+  end
+
+  def require_stormfile!
+    stormfile = File.expand_path(options[:stormfile])
+    raise Thor::Error, "Stormfile at '#{options[:stormfile]}' not found!" unless File.exists? stormfile
+    load options[:stormfile]
+  end
+
+  def handle_authentication_error(exception)
+    raise Thor::Error, "Authentication error, check your credentials or run 'stormforge auth' again!"
+  end
+
+  def authentication
+    return @authentication if @authentication
+
+    raise Thor::Error, "No authentication file found" unless File.exists? authfile
+
+    auth = JSON.parse(File.read(authfile))
+
+    raise Thor::Error, "Authentication file invalid. Use 'stormforger auth' to generate a new one." unless auth["email"].present? && auth["authentication_token"].present?
+
+    @authentication = auth
+  end
+
+  def authfile
+    path = File.expand_path(options[:authfile])
+    path += ".dev" if dev_mode?
+    path
+  end
+
+  def dev_mode?
+    !!options[:development]
+  end
+end

data/lib/thor/testcase.rb

@@ -0,0 +1,23 @@
+class StormForge::Thor::Testcase < StormForge::Thor::Base
+  desc "update NAME", "Update test case NAME"
+  def update(name)
+    require_stormfile!
+
+    test_case = StormForge.test_case(name.to_sym)
+
+    raise Thor::Error, "Test case '#{name}' unknown!" unless test_case
+
+    client.create_or_update(test_case)
+  rescue Faraday::Error::ConnectionFailed
+    raise Thor::Error, "StormForger API not available :-/ (connection failed)"
+  end
+
+  desc "list", "List all defined test cases"
+  def list
+    require_stormfile!
+
+    StormForge.registry.each_pair do |name, test_case|
+      puts name
+    end
+  end
+end

data/lib/thor/testrun.rb

@@ -0,0 +1,75 @@
+class StormForge::Thor::Testrun < StormForge::Thor::Base
+  desc "list [TEST_CASE]", "List test runs"
+  def list(test_case_slug=nil)
+    require_stormfile!
+
+    test_runs = client.list_test_runs(test_case_slug)["test_runs"]
+    test_case = test_case_slug.present? ? "test case '#{test_case_slug}'" : "all test cases"
+    puts "Test Run ID & Description for #{test_case}"
+    test_runs.each do |test_run|
+      puts "#{test_run["id"].to_s} (#{test_run["state"]}): #{test_run["description"] || '-'}"
+    end
+  rescue Faraday::Error::ConnectionFailed
+    raise Thor::Error, "StormForger API not available :-/ (connection failed)"
+  rescue Faraday::Error::ResourceNotFound
+    raise Thor::Error, "Test case '#{test_case_slug}' not found!"
+  rescue Faraday::Error::ClientError => e
+    if e.response[:status] == 401
+      handle_authentication_error(e)
+    else
+      raise e
+    end
+  end
+
+  desc "create TEST_CASE [DESCRIPTION]", "Create a test run"
+  def create(test_case_slug, description="")
+    require_stormfile!
+
+    p client.create_test_run(test_case_slug, description)
+  rescue Faraday::Error::ConnectionFailed
+    raise Thor::Error, "StormForger API not available :-/ (connection failed)"
+  rescue Faraday::Error::ResourceNotFound
+    raise Thor::Error, "Test Run could not be created, test case '#{test_case_slug}' not found!"
+  end
+
+  desc "show TEST_RUN_ID", "Show a test run"
+  def show(test_run_id)
+    require_stormfile!
+
+    test_run = client.fetch_test_run(test_run_id)
+    pp test_run
+  rescue Faraday::Error::ConnectionFailed
+    raise Thor::Error, "StormForger API not available :-/ (connection failed)"
+  rescue Faraday::Error::ResourceNotFound
+    raise Thor::Error, "Test Run #{test_run_id} not found!"
+  end
+
+  desc "stats TEST_RUN_ID", "Get stats (WIP)"
+  method_option :stream, type: :boolean, default: true, desc: "WIP: Stream"
+  method_option :limit, type: :numeric, default: 10, desc: "Limit of stats per batch"
+  def stats(test_run_id, since=0)
+    require_stormfile!
+
+    client.test_run_log(test_run_id, since, options[:limit], options[:stream]) do |stats|
+      puts stats.to_json
+    end
+  end
+
+  desc "abort TEST_RUN_ID", "Abort a test run"
+  def abort(test_run_id)
+    require_stormfile!
+
+    test_run = client.abort_test_run(test_run_id)
+    puts test_run.inspect
+  rescue Faraday::Error::ConnectionFailed
+    raise Thor::Error, "StormForger API not available :-/ (connection failed)"
+  rescue Faraday::Error::ResourceNotFound
+    raise Thor::Error, "Test Run #{test_run_id} not found"
+  rescue Faraday::Error::ClientError => e
+    if e.response[:status] == 422
+      raise Thor::Error, "Test Run #{test_run_id} cannot be aborted!"
+    else
+      raise e
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,4 @@
+require "spec_helper"
+
+describe StormForge::Client do
+end

data/spec/dsl/test_case/attribute_access_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+class Foo
+  include StormForge::Dsl::TestCase::AttributeAccess
+
+  def initialize
+    @attributes = {}
+  end
+
+  def available_attributes
+    [:title]
+  end
+end
+
+describe StormForge::Dsl::TestCase::AttributeAccess do
+  it "should tell if it responds to a given attribute" do
+    foo = Foo.new
+    foo.respond_to?(:title).should == true
+  end
+
+  it "should be able to set the configured attribute's values (DSL style)" do
+    foo = Foo.new
+    foo.title "new title"
+    foo.title.should == "new title"
+  end
+
+  it "should be able to set the configured attribute's values via setter" do
+    foo = Foo.new
+    foo.title = "new title"
+    foo.title.should == "new title"
+  end
+
+  it "should delegate to super if no specified attribute matches" do
+    foo = Foo.new
+    expect do
+      foo.something
+    end.to raise_error(NoMethodError)
+  end
+
+  it "should not allow more than one argument to generated attribute accessors" do
+    foo = Foo.new
+    expect do
+      foo.title "new title", "meh?"
+    end.to raise_error(ArgumentError)
+  end
+end

data/spec/dsl/test_case/cloud_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe StormForge::Dsl::TestCase::Cloud do
+  describe "Validations" do
+    subject { StormForge::Dsl::TestCase::Cloud.new :aws, Proc.new {} }
+    it { should ensure_inclusion_of(:provider).in_array(StormForge::Dsl::TestCase::Cloud.supported_cloud_providers) }
+  end
+
+  it "should have security groups" do
+    cloud = StormForge::Dsl::TestCase::Cloud.new :aws do
+      security_groups "sg-12345", "sg-abcdef"
+    end
+    cloud.security_groups.should include("sg-12345", "sg-abcdef")
+  end
+end

data/spec/dsl/test_case/data_source/file_fixture_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe StormForge::Dsl::TestCase::DataSource::FileFixture do
+  subject { StormForge::Dsl::TestCase::DataSource::FileFixture }
+
+  describe "Validations" do
+    it "should require a name" do
+      users = subject.new(nil, {})
+      users.valid?
+      users.errors[:name].should be_present
+    end
+
+    it "should default order to :sequentially" do
+      users = subject.new("a name", {})
+      users.order.should == :sequentially
+    end
+
+    it "should require an existing source" do
+      users = subject.new("users", source: "NOT-EXISTING")
+      users.valid?
+      users.errors[:source].should be_present
+    end
+
+    it "should actually check for an existing source" do
+      users = subject.new("users", source: File.join(FIXTURE_PATH, "users.csv"))
+      users.valid?
+      users.errors[:source].should be_blank
+    end
+  end
+
+  describe "#delimiter" do
+    it "should have a delimiter" do
+      subject.new("a name", delimiter: "!").delimiter.should == "!"
+    end
+
+    it "should have a default delimiter" do
+      subject.new("a name", {}).delimiter.should == ";"
+    end
+  end
+
+  # TODO this spec feels messy, refactor it!
+  it "should calculate a md5_hash from the source file" do
+    file = "/foo/bar/fixture.csv"
+    File.should_receive(:exist?).with(file).and_return(true)
+
+    file_fixture = subject.new("blub", source: file)
+
+    md5_file_double = double()
+    md5_file_double.should_receive(:hexdigest).and_return("md5")
+    ::Digest::MD5.should_receive(:file).with(file).and_return(md5_file_double)
+
+    file_fixture.md5_hash.should == "md5"
+  end
+
+  # TODO this spec feels messy, refactor it!
+  it "#as_json" do
+    file = "/foo/bar/fixture.csv"
+    file_fixture = subject.new("blub", source: file)
+    file_fixture.should_receive(:md5_hash).and_return("md5_hash")
+
+    json = file_fixture.as_json
+
+    json[:source] = File.basename(file)
+    json[:md5_hash] = "md5"
+  end
+
+  describe "#next" do
+    context "no fields given" do
+      it "should return a marker and start with a sequence number of 1" do
+        subject.new("requests", {}).next.should == "${FILEFIXTURE|n=requests-seq=1}"
+      end
+
+      it "should increment the sequence on each call to #next" do
+        users = subject.new("users", {})
+        users.next.should == "${FILEFIXTURE|n=users-seq=1}"
+        users.next.should == "${FILEFIXTURE|n=users-seq=2}"
+      end
+    end
+
+    context "fields given" do
+      it "should increment the sequence on each call to #next" do
+        users = subject.new("users", fields: [:id, :email, :password])
+        users.next.email.should == "${FILEFIXTURE|f=email-n=users-seq=1}"
+        users.next.id.should == "${FILEFIXTURE|f=id-n=users-seq=2}"
+      end
+    end
+
+    it "should raise NoMethodError on proxy when invalid field is given" do
+      users = subject.new("users", fields: [:id, :email, :password])
+      expect { users.next.i_do_not_exist}.to raise_error(NoMethodError)
+    end
+
+    it "should be a good ruby citizen and implement respond_to_missing" do
+      users = subject.new("users", fields: [:id, :email, :password])
+      # users.next.send(:respond_to_missing?, :foo).should == false
+      users.next.send(:respond_to_missing?, :id).should == true
+    end
+  end
+
+end
+

data/spec/dsl/test_case/data_source/random_number_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe StormForge::Dsl::TestCase::DataSource::RandomNumber do
+  subject { StormForge::Dsl::TestCase::DataSource::RandomNumber }
+
+  it "should return a marker and start with a sequence number of 1" do
+    subject.new("number", range: 1..10).next.should == "${GENERATOR|t=random_number-n=number-seq=1}"
+  end
+
+  it "should increment the sequence on each call to #next" do
+    foo = subject.new("another_number", range: 23..42)
+    foo.next.should == "${GENERATOR|t=random_number-n=another_number-seq=1}"
+    foo.next.should == "${GENERATOR|t=random_number-n=another_number-seq=2}"
+  end
+
+  it "should know how often #next was called" do
+    ref_token = subject.new("ref_token", range: 10..42)
+    2.times { ref_token.next }
+    ref_token.count.should == 2
+  end
+
+  it "should work with an array for range too" do
+    subject.new("number", range: [23, 42]).range.should == (23..42)
+  end
+
+  describe "Invalid range options" do
+    it "should not accept missing range" do
+      expect {
+        subject.new("numer_without_range", range: nil)
+      }.to raise_error(StormForge::Dsl::TestCase::DataSource::RandomNumber::InvalidRange)
+    end
+
+    it "should not accept non-numerical range" do
+      expect {
+        subject.new("numer_with_invalid", range: "a".."z")
+      }.to raise_error(StormForge::Dsl::TestCase::DataSource::RandomNumber::InvalidRange)
+    end
+
+    it "should not accept range beginning below 0" do
+      expect {
+        subject.new("numer_with_invalid_range", range: -1..10)
+      }.to raise_error(StormForge::Dsl::TestCase::DataSource::RandomNumber::InvalidRange)
+    end
+
+    it "should not accept range beginning over 100_000_000" do
+      expect {
+        subject.new("numer_with_invalid_range", range: 1..100_000_001)
+      }.to raise_error(StormForge::Dsl::TestCase::DataSource::RandomNumber::InvalidRange)
+    end
+  end
+end

data/spec/dsl/test_case/data_source/random_string_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe StormForge::Dsl::TestCase::DataSource::RandomString do
+  subject { StormForge::Dsl::TestCase::DataSource::RandomString }
+
+  it "should return a marker and start with a sequence number of 1" do
+    subject.new("ref_token", length: 10).next.should == "${GENERATOR|t=random_string-n=ref_token-seq=1}"
+  end
+
+  it "should increment the sequence for every invocation of #next" do
+    ref_token = subject.new("ref_token", length: 10)
+    ref_token.next.should == "${GENERATOR|t=random_string-n=ref_token-seq=1}"
+    ref_token.next.should == "${GENERATOR|t=random_string-n=ref_token-seq=2}"
+  end
+
+  it "should know how often #next was called" do
+    ref_token = subject.new("ref_token", length: 10)
+    2.times { ref_token.next }
+    ref_token.count.should == 2
+  end
+
+  it "should default to length of 1" do
+    subject.new("token_length_1", {}).length.should == 1
+  end
+
+  it "should limit the length to 100" do
+    subject.new("long_token", length: 101).length.should == 100
+  end
+
+  it "should ensure that length is a number" do
+    subject.new("ref_token", length: "meh").length.should == 1
+  end
+end

data/spec/dsl/test_case/data_source_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe StormForge::Dsl::TestCase::DataSource do
+  describe "Usage" do
+    subject { StormForge::Dsl::TestCase::DataSource }
+
+    it "spec_name" do
+      subject.new Proc.new {}
+    end
+  end
+end
+

data/spec/dsl/test_case/definition_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe StormForge::Dsl::TestCase::Definition do
+
+  describe "Validations" do
+
+    subject { StormForge::Dsl::TestCase::Definition.new :slug, Proc.new {} }
+    before(:each) { subject.valid? }
+
+    it "requires a title" do
+      subject.errors[:title].should be_present
+    end
+
+    it "requires a version" do
+      subject.errors[:version].should be_present
+    end
+
+    it "requires at least one target" do
+      subject.errors[:targets].should be_present
+      test_case = StormForge::Dsl::TestCase::Definition.new :slug do
+        targets "target1"
+      end
+      test_case.valid?
+      test_case.errors[:targets].should be_empty
+    end
+
+    it "requires at least one arrival phase" do
+      subject.errors[:arrival_phases].should be_present
+    end
+
+    it "requires at least one session" do
+      subject.errors[:sessions].should be_present
+    end
+
+    it "requires to have a total session probability of 100%" do
+      test_case = StormForge::Dsl::TestCase::Definition.new :slug do
+        session "a", 10, Proc.new {}
+      end
+      test_case.valid?
+      test_case.errors[:sessions].should be_present
+
+      test_case = StormForge::Dsl::TestCase::Definition.new :slug do
+        session "a", 100, Proc.new {}
+      end
+      test_case.valid?
+      test_case.errors[:sessions].should be_empty
+    end
+
+  end
+
+  it "should have a description" do
+    test_case = StormForge::Dsl::TestCase::Definition.new :slug do
+      description "test case description"
+    end
+
+    test_case.description.should == "test case description"
+  end
+
+  it "should have cloud configuration" do
+    expect {
+      StormForge::Dsl::TestCase::Definition.new :slug do
+        self.respond_to?(:cloud).should == true
+        cloud :provider, Proc.new {}
+      end
+    }.not_to raise_error
+  end
+
+  it "should serialize to JSON" do
+    test_case = StormForge::Dsl::TestCase::Definition.new :my_1st_case_title do
+      title "my 1st case title"
+      version "version"
+      targets "a1"
+      arrival_phase duration: 1.hour, rate: 100.per_second
+      session "GET /", 100.percent, Proc.new {}
+    end
+
+    # do a sanity check, to verify that the test_case is valid
+    test_case.valid?
+    test_case.errors.should be_empty
+
+    test_case.to_json(root: false).should match_json_expression({
+      dsl_version: :v1,
+      slug: "my_1st_case_title",
+      title: "my 1st case title",
+      version: "version",
+      targets: ["a1"],
+      arrival_phases: [
+        {
+          warmup: false,
+          duration: 3600,
+          duration_unit: :second,
+          rate: 100.0,
+          rate_unit: :second
+        }
+      ].ordered!,
+      data_sources: nil,
+      sessions: {
+        "GET /" => {
+          name: "GET /",
+          probability: 100,
+          steps: [],
+          data_sources_usage: {}
+        }
+      }
+    })
+  end
+end