webhookdb 0.1.0

data/lib/webhookdb/spec_helpers/citest.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "webhookdb/slack"
+require "webhookdb/spec_helpers"
+
+module Webhookdb::SpecHelpers::Citest
+  def self.run_tests(folder)
+    out = StringIO.new
+    err = StringIO.new
+    RSpec::Core::Runner.run([folder + "/", "--format", "html"], err, out)
+
+    notifier = Webhookdb::Slack.new_notifier(
+      force_channel: "#webhookdb-notifications",
+      username: "CI Tests",
+      icon_emoji: ":female-detective:",
+    )
+    outstring = out.string
+    result = Webhookdb::SpecHelpers::Citest.parse_rspec_html(outstring)
+    unless result.ok?
+      msg = "Errored or unparseable output running #{folder} tests:\nerror: #{err.string}\nout: #{outstring}"
+      notifier.post text: msg
+      return
+    end
+
+    url = self.put_results(folder, result.html)
+    payload = self.result_to_payload(folder, result, url)
+    notifier.post(payload)
+  end
+
+  def self.parse_rspec_html(output)
+    result = RSpecResult.new
+    html = []
+    output.lines.each do |line|
+      next if line.strip.start_with?("Run options") || line.strip.starts_with?("All examples were")
+      html << line
+      captures = line.match(/innerHTML = "(\d+ examples?), (\d+ failures?)(, )?(\d+ pending)?/)&.captures
+      next unless captures
+      result.examples = captures[0].to_i
+      result.failures = captures[1].to_i
+      result.pending = captures[3].to_i
+    end
+    result.html = html.join
+    return result
+  end
+
+  def self.put_results(folder, html)
+    now = Time.now
+    key = "test-results/#{folder}/#{now.year}/#{now.month}/#{now.in_time_zone('UTC').iso8601}.html"
+    doc = Webhookdb::DatabaseDocument.create(
+      key:,
+      content: html,
+      content_type: "text/html",
+    )
+    url = doc.presigned_view_url(expire_at: 1.week.from_now)
+    return url
+  end
+
+  def self.result_to_payload(folder, result, html_url)
+    color = "good"
+    color = "warning" if result.pending.nonzero?
+    color = "danger" if result.failures.nonzero?
+
+    return {
+      text: "Tests for #{folder}: #{result.examples} examples, #{result.failures} failures, #{result.pending} pending",
+      attachments: [
+        {
+          color:,
+          fallback: "View results at #{html_url}",
+          actions: [
+            {
+              type: "button",
+              text: "View Results 🔎",
+              url: html_url,
+            },
+          ],
+        },
+      ],
+    }
+  end
+
+  class RSpecResult
+    attr_accessor :html, :examples, :failures, :pending
+
+    def ok?
+      return !self.examples.nil?
+    end
+  end
+end

data/lib/webhookdb/spec_helpers/integration.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "appydays/configurable"
+require "httparty"
+require "rspec"
+require "rspec/eventually"
+
+require "webhookdb"
+require "webhookdb/async"
+
+raise "integration tests not enabled, this file should not have been evaluated" unless
+  Webhookdb::INTEGRATION_TESTS_ENABLED
+
+module Webhookdb::IntegrationSpecHelpers
+  include Appydays::Configurable
+  include Appydays::Loggable
+
+  def self.included(context)
+    # We run few workers on staging so need time to process things.
+    Rspec::Eventually.timeout = 60
+    # We're in no rush for integration tests.
+    Rspec::Eventually.pause = 1
+
+    context.before(:each) do |example|
+      raise "Unit tests should not be run during integration tests (or this test needs an :integration flag" unless
+        example.metadata[:integration]
+
+      @to_destroy = []
+      WebMock.allow_net_connect!
+    end
+
+    context.after(:each) do
+      @to_destroy.each(&:destroy)
+      WebMock.disable_net_connect!
+    end
+    super
+  end
+
+  module_function def with_async_publisher
+    Amigo.install_amigo_jobs
+    yield
+  ensure
+    Amigo.subscribers.clear
+  end
+
+  module_function def url(more)
+    return "#{Webhookdb.api_url}#{more}"
+  end
+
+  module_function def parse_cookie(resp)
+    cookie_hash = HTTParty::CookieHash.new
+    resp.get_fields("Set-Cookie")&.each { |c| cookie_hash.add_cookies(c) }
+    return cookie_hash
+  end
+
+  module_function def store_cookies
+    response = yield()
+    @stored_cookies = parse_cookie(response)
+    Webhookdb::IntegrationSpecHelpers.logger.debug "Got cookies: %p" % [stored_cookies]
+    return response
+  end
+
+  module_function def stored_cookies
+    return @stored_cookies
+  end
+
+  module_function def auth_customer(customer=nil)
+    if customer.nil?
+      customer = Webhookdb::Fixtures.customer.instance
+      resp = post("/v1/auth", body: {email: customer.email})
+      expect(resp).to party_status(202)
+      customer = Webhookdb::Customer[email: customer.email]
+    end
+
+    code = Webhookdb::Fixtures.reset_code(customer:).create
+    resp = post("/v1/auth", body: {email: customer.email, token: code.token})
+    expect(resp).to party_status(200)
+
+    return customer.refresh
+  end
+
+  [:get, :post, :put, :patch, :delete].each do |method|
+    define_method(method) do |url_, opts={}|
+      opts[:headers] ||= {}
+      store_cookies do
+        cookie_header = stored_cookies&.to_cookie_string
+        opts[:headers] = opts[:headers].merge("Cookie" => cookie_header) if cookie_header.present?
+        if opts.delete(:json)
+          opts[:headers]["Content-Type"] = "application/json"
+          opts[:body] = opts[:body].to_json unless opts[:body].is_a?(String)
+        end
+        Webhookdb::IntegrationSpecHelpers.logger.info "%s %s %s" % [method.upcase, url_, opts]
+        HTTParty.send(method, url(url_), opts)
+      end
+    end
+    module_function method
+  end
+end
+
+# Check that an HTTParty::Response code matches the expected.
+RSpec::Matchers.define(:party_status) do |expected_status|
+  match do |response|
+    response.code == expected_status
+  end
+
+  failure_message do |response|
+    "expected response code %d, got a %d response instead\nBody: %s" %
+      [expected_status, response.code, response.parsed_response]
+  end
+end
+
+# Match a parsed Response hash (deep symbol keys) against an RSpec matcher.
+RSpec::Matchers.define(:party_response) do |matcher|
+  match do |response|
+    matcher.matches?(response.parsed_response.deep_symbolize_keys)
+  end
+
+  failure_message do
+    matcher.failure_message
+  end
+end

data/lib/webhookdb/spec_helpers/message.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "webhookdb/spec_helpers"
+
+module Webhookdb::SpecHelpers::Message
+  def self.included(context)
+    context.before(:each) do |example|
+      if example.metadata[:messaging]
+        Webhookdb::Message::Transport.override = :fake
+        Webhookdb::Message::FakeTransport.reset!
+      end
+    end
+
+    context.after(:each) do |example|
+      if example.metadata[:messaging]
+        Webhookdb::Message::Transport.override = nil
+        Webhookdb::Message::FakeTransport.reset!
+      end
+    end
+
+    super
+  end
+
+  # Retrieve the last sent email from the local mailpit service.
+  module_function def fetch_last_email
+    old = WebMock::Config.instance.allow
+    mpurl = Webhookdb::Message::EmailTransport.mailpit_url
+    getopts = {timeout: 5, logger: nil}
+    WebMock::Config.instance.allow = mpurl
+    begin
+      list_resp = Webhookdb::Http.get("#{mpurl}/api/v1/messages", {limit: 1}, **getopts)
+      msg = list_resp.parsed_response.fetch("messages").first
+      msgid = msg.fetch("ID")
+      headers_resp = Webhookdb::Http.get("#{mpurl}/api/v1/message/#{msgid}/headers", **getopts)
+      msg["Headers"] = headers_resp.parsed_response
+      return msg
+    ensure
+      WebMock::Config.instance.allow = old
+    end
+  end
+end

data/lib/webhookdb/spec_helpers/postgres.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "webhookdb/postgres"
+require "webhookdb/spec_helpers"
+
+# Some helper functions for testing. Usage:
+#
+#    # in spec/spec_helper.rb
+#    RSpec.configure do |c|
+#      c.include( Webhookdb::SpecHelpers::Postgres )
+#    end
+#
+#    # in my_class_spec.rb; mark an example as needing database setup
+#    describe MyClass, db: true do
+#    end
+#
+module Webhookdb::SpecHelpers::Postgres
+  extend Webhookdb::MethodUtilities
+
+  # Pathname constants
+  BASEDIR = Pathname(__FILE__).dirname.parent
+  SPECDIR = BASEDIR + "spec"
+  DATADIR = SPECDIR + "data"
+
+  SNIFF_LEAKY_TESTS = false
+
+  Webhookdb::Postgres.register_model("webhookdb/postgres/testing_pixie")
+
+  ### Inclusion callback -- install some hooks
+  def self.included(context)
+    context.around(:each) do |example|
+      Webhookdb::Postgres.unsafe_skip_transaction_check = true if example.metadata[:no_transaction_check]
+
+      setting = example.metadata[:db]
+      if setting && setting != :no_transaction
+        Webhookdb::SpecHelpers::Postgres.wrap_example_in_transactions(example)
+      else
+        Webhookdb::Postgres.logger.debug "Running spec without a transaction"
+        example.run
+      end
+    end
+
+    context.after(:each) do |example|
+      Webhookdb::Postgres.unsafe_skip_transaction_check = false if example.metadata[:no_transaction_check]
+
+      truncate_all if example.metadata[:db] == :no_transaction
+    end
+
+    super
+  end
+
+  ### Run the specified +example+ in the context of a transaction for each loaded
+  ### model superclass. Raises if any of the loaded superclasses aren't
+  ### configured.
+  def self.wrap_example_in_transactions(example)
+    txn_classes = Webhookdb::Postgres.model_superclasses
+    Webhookdb::Postgres.logger.debug "Wrapping example for model superclasses: %p" %
+      [txn_classes]
+
+    wrapped_proc = txn_classes.inject(example.method(:run)) do |callback, txn_class|
+      if (db = txn_class.db)
+        Webhookdb::Postgres.logger.debug "DB: Running with an outer transaction"
+        proc { db.transaction(auto_savepoint: :only, rollback: :always, &callback) }
+      else
+        raise "No database connection for %p configured! Add a %s section to the test config." %
+          [txn_class, txn_class.config_key]
+      end
+    end
+
+    wrapped_proc.call
+    return if !SNIFF_LEAKY_TESTS || (Webhookdb::Customer.empty? && Webhookdb::Organization.empty?)
+    puts "Customer is not cleaned up, failing for diagnosis."
+    puts "Check the spec that ran before: #{example.metadata[:full_description]}"
+    exit
+  end
+
+  singleton_attr_accessor :current_test_model_uid
+  self.current_test_model_uid = 0
+
+  module Models; end
+
+  # Create an anonymous model with the given table name.
+  # Can be a symbol, string, or [:schema, :table] array.
+  module_function def create_model(name, &)
+    Webhookdb::SpecHelpers::Postgres.current_test_model_uid += 1
+
+    qualifier = Sequel
+    prefix = name
+    if name.is_a?(Array)
+      qualifier = Sequel[name[0]]
+      Webhookdb::Postgres::Model.create_schema!(qualifier)
+      prefix = name[1]
+    end
+    table_name = :"testtable_#{prefix}_#{Webhookdb::SpecHelpers::Postgres.current_test_model_uid}"
+    qualified_name = qualifier[table_name]
+
+    Webhookdb::Postgres.logger.info "Creating table: %p" % [qualified_name]
+    Webhookdb::Postgres::Model.db.create_table!(qualified_name, &)
+    clsname = table_name.to_s.classify
+    clsfqn = "#{Webhookdb::SpecHelpers::Postgres::Models}::#{clsname}"
+    cls = Class.new(Webhookdb::Postgres::Model(qualified_name)) do
+      define_singleton_method(:name) { clsfqn }
+    end
+    Webhookdb::SpecHelpers::Postgres::Models.const_set(clsname, cls)
+    # Object.const_get(clsfqn)
+    return cls
+  end
+
+  module_function def truncate_all
+    # We can delete items from 'leaf' to 'trunk' in association terms
+    # by using the TSort API (so Address and Customer, for example, are very early,
+    # while 'StripeAttributes', which nothing has an FK into, is very late).
+    # This is much faster than truncating with cascade.
+    # Though in some cases, it doesn't work, so we need to cascade.
+    Webhookdb::Postgres.each_model_superclass do |sc|
+      sc.tsort.reverse_each do |m|
+        m.dataset.delete
+      rescue Sequel::ForeignKeyConstraintViolation
+        m.truncate(cascade: true)
+      rescue Sequel::DatabaseError
+        # The table may not exist, maybe because the type was created in a test
+        # and now no longer exists but it still a subclass.
+        nil
+      end
+    end
+  end
+
+  #
+  # Custom matchers
+  #
+
+  RSpec::Matchers.define(:be_saved) do
+    match do |model_object|
+      !model_object.new?
+    end
+  end
+
+  class HaveRowMatcher
+    include RSpec::Matchers
+
+    def initialize(criteria)
+      @criteria = criteria
+    end
+
+    def matches?(model)
+      @model = model
+      @instance = @model[@criteria]
+      return false if @instance.nil?
+
+      return @matcher.matches?(@instance) if @matcher
+
+      return true
+    end
+
+    def failure_message
+      return "Expected %s to have a row matching criteria %p but did not" % [@model.name, @criteria] unless @instance
+      return "Row found but matcher failed with: %s" % [@matcher.failure_message] if @matcher
+      return "invalid message"
+    end
+
+    def failure_message_when_negated
+      return "Expected %s to not have a row matching criteria %p but did" % [@model.name, @criteria] if @instance
+      return "invalid message"
+    end
+
+    def with_attributes(attrs)
+      @matcher = RSpec::Matchers::BuiltIn::HaveAttributes.new(attrs)
+      return self
+    end
+  end
+
+  module_function def have_row(criteria)
+    return HaveRowMatcher.new(criteria)
+  end
+
+  # Matcher that checks that hashes have the same id as objects.
+  #
+  #   expect( last_response_json_body ).to have_same_ids_as( dataset.all )
+  #
+  RSpec::Matchers.define(:have_same_ids_as) do |*expected|
+    match do |actual|
+      @pk ||= :id
+      self.ids(actual) == self.ids(expected.flatten)
+    end
+
+    failure_message do |actual|
+      "expected ids %s to equal ids %s" % [self.ids(actual), self.ids(expected.flatten)]
+    end
+
+    chain :ordered do
+      @ordered = true
+    end
+
+    chain :pk_field do |pk|
+      @pk = pk
+    end
+
+    def ids(arr)
+      res = arr.map { |o| self.id(o) }
+      res = res.sort unless @ordered
+      return res
+    end
+
+    def id(o)
+      return o if o.is_a?(Numeric)
+      return o.send(@pk) if o.respond_to?(@pk)
+      return o[@pk] || o[@pk.to_s]
+    end
+  end
+
+  RSpec::Matchers.define(:be_destroyed) do
+    match do |actual|
+      actual.class.where(id: actual.id).empty?
+    end
+
+    failure_message do |actual|
+      "did not expect to find item with id %s in %s" % [actual.id, actual.class.where(id: actual.id).all]
+    end
+  end
+end