chemlab 0.0.1 → 0.1.0

data/qa/resource/user.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-
-module QA
-  module Resource
-    class User < Base
-      attr_reader :unique_id
-      attr_writer :username, :password
-      attr_accessor :admin, :provider, :extern_uid
-
-      attribute :id
-      attribute :name
-      attribute :email
-
-      def initialize
-        @admin = false
-        @unique_id = SecureRandom.hex(8)
-      end
-
-      def admin?
-        api_resource&.dig(:is_admin) || false
-      end
-
-      def username
-        @username || "qa-user-#{unique_id}"
-      end
-
-      def password
-        @password || 'password'
-      end
-
-      def name
-        @name ||= api_resource&.dig(:name) || "QA User #{unique_id}"
-      end
-
-      def email
-        @email ||= begin
-          api_email = api_resource&.dig(:email)
-          api_email && !api_email.empty? ? api_email : "#{username}@example.com"
-        end
-      end
-
-      def public_email
-        @public_email ||= begin
-          api_public_email = api_resource&.dig(:public_email)
-
-          api_public_email && !api_public_email.empty? ? api_public_email : Runtime::User.default_email
-        end
-      end
-
-      def credentials_given?
-        defined?(@username) && defined?(@password)
-      end
-
-      def fabricate!
-        # Don't try to log-out if we're not logged-in
-        if Page::Main::Menu.perform { |p| p.has_personal_area?(wait: 0) }
-          Page::Main::Menu.perform { |main| main.sign_out }
-        end
-
-        if credentials_given?
-          Page::Main::Login.perform do |login|
-            login.sign_in_using_credentials(user: self)
-          end
-        else
-          Page::Main::Login.perform do |login|
-            login.switch_to_register_tab
-          end
-          Page::Main::SignUp.perform do |signup|
-            signup.sign_up!(self)
-          end
-        end
-      end
-
-      def fabricate_via_api!
-        resource_web_url(api_get)
-      rescue ResourceNotFoundError
-        super
-      end
-
-      def api_delete
-        super
-
-        QA::Runtime::Logger.debug("Deleted user '#{username}'")
-      end
-
-      def api_delete_path
-        "/users/#{id}"
-      end
-
-      def api_get_path
-        return "/user" if fetching_own_data?
-
-        "/users/#{fetch_id(username)}"
-      end
-
-      def api_post_path
-        '/users'
-      end
-
-      def api_post_body
-        {
-          admin: admin,
-          email: email,
-          password: password,
-          username: username,
-          name: name,
-          skip_confirmation: true
-        }.merge(ldap_post_body)
-      end
-
-      def self.fabricate_or_use(username = nil, password = nil)
-        if Runtime::Env.signup_disabled?
-          self.fabricate_via_api! do |user|
-            user.username = username
-            user.password = password
-          end
-        else
-          self.fabricate!
-        end
-      end
-
-      private
-
-      def ldap_post_body
-        return {} unless extern_uid && provider
-
-        {
-            extern_uid: extern_uid,
-            provider: provider
-        }
-      end
-
-      def fetch_id(username)
-        users = parse_body(api_get_from("/users?username=#{username}"))
-
-        unless users.size == 1 && users.first[:username] == username
-          raise ResourceNotFoundError, "Expected one user with username #{username} but found: `#{users}`."
-        end
-
-        users.first[:id]
-      end
-
-      def fetching_own_data?
-        user&.username == username || Runtime::User.username == username
-      end
-    end
-  end
-end

data/qa/resource/user_gpg.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Resource
-    class UserGPG < Base
-      attr_accessor :id, :gpg
-      attr_reader :key_id
-
-      def initialize
-        @gpg = Runtime::GPG.new
-        @key_id = @gpg.key_id
-      end
-
-      def fabricate_via_api!
-        super
-        @id = self.api_response[:id]
-      rescue ResourceFabricationFailedError => error
-        if error.message.include? 'has already been taken'
-          self
-        else
-          raise ResourceFabricationFailedError error
-        end
-      end
-
-      def resource_web_url(resource)
-        super
-      rescue ResourceURLMissingError
-        # this particular resource does not expose a web_url property
-      end
-
-      def api_get_path
-        "/user/gpg_keys/#{@id}"
-      end
-
-      def api_post_path
-        '/user/gpg_keys'
-      end
-
-      def api_post_body
-        {
-          key: @gpg.key
-        }
-      end
-    end
-  end
-end

data/qa/resource/visibility.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Resource
-    module Visibility
-      def set_visibility(visibility)
-        put Runtime::API::Request.new(api_client, api_visibility_path).url, { visibility: visibility }
-      end
-
-      class VisibilityLevel
-        %i(public internal private).each do |level|
-          const_set(level.upcase, level)
-        end
-      end
-    end
-  end
-end

data/qa/resource/wiki.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Resource
-    class Wiki < Base
-      attr_accessor :title, :content, :message
-
-      attribute :project do
-        Project.fabricate! do |resource|
-          resource.name = 'project-for-wikis'
-          resource.description = 'project for adding wikis'
-        end
-      end
-
-      attribute :repository_http_location do
-        Page::Project::Wiki::Show.perform(&:click_clone_repository)
-
-        Page::Project::Wiki::GitAccess.perform do |git_access|
-          git_access.choose_repository_clone_http
-          git_access.repository_location
-        end
-      end
-
-      attribute :repository_ssh_location do
-        Page::Project::Wiki::Show.perform(&:click_clone_repository)
-
-        Page::Project::Wiki::GitAccess.perform do |git_access|
-          git_access.choose_repository_clone_ssh
-          git_access.repository_location
-        end
-      end
-
-      def fabricate!
-        project.visit!
-
-        Page::Project::Menu.perform { |menu_side| menu_side.click_wiki }
-
-        Page::Project::Wiki::New.perform do |wiki_new|
-          wiki_new.click_create_your_first_page_button
-          wiki_new.set_title(@title)
-          wiki_new.set_content(@content)
-          wiki_new.set_message(@message)
-          wiki_new.create_new_page
-        end
-      end
-    end
-  end
-end

data/qa/runtime/address.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    class Address
-      attr_reader :address
-
-      def initialize(instance, page)
-        @instance = instance
-        @address  = host + (page.is_a?(String) ? page : page&.path)
-      end
-
-      def host
-        if @instance.is_a?(Symbol)
-          Runtime::Scenario.send("#{@instance}_address")
-        else
-          @instance.to_s
-        end
-      end
-
-      def self.valid?(value)
-        uri = URI.parse(value)
-        uri.is_a?(URI::HTTP) && !uri.host.nil?
-      rescue URI::InvalidURIError
-        false
-      end
-    end
-  end
-end

data/qa/runtime/api/client.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'airborne'
-
-module QA
-  module Runtime
-    module API
-      class Client
-        attr_reader :address, :user
-
-        def initialize(address = :gitlab, personal_access_token: nil, is_new_session: true, user: nil, ip_limits: false)
-          @address = address
-          @personal_access_token = personal_access_token
-          @is_new_session = is_new_session
-          @user = user
-          enable_ip_limits if ip_limits
-        end
-
-        def personal_access_token
-          @personal_access_token ||= begin
-            # you can set the environment variable GITLAB_QA_ACCESS_TOKEN
-            # to use a specific access token rather than create one from the UI
-            # unless a specific user has been passed
-            @user.nil? ? Runtime::Env.personal_access_token ||= create_personal_access_token : create_personal_access_token
-          end
-        end
-
-        def self.as_admin
-          if Runtime::Env.admin_personal_access_token
-            Runtime::API::Client.new(:gitlab, personal_access_token: Runtime::Env.admin_personal_access_token)
-          else
-            user = Resource::User.fabricate_via_api! do |user|
-              user.username = Runtime::User.admin_username
-              user.password = Runtime::User.admin_password
-            end
-
-            unless user.admin?
-              raise AuthorizationError, "User '#{user.username}' is not an administrator."
-            end
-
-            Runtime::API::Client.new(:gitlab, user: user)
-          end
-        end
-
-        private
-
-        def enable_ip_limits
-          Page::Main::Menu.perform(&:sign_out) if Page::Main::Menu.perform { |p| p.has_personal_area?(wait: 0) }
-
-          Runtime::Browser.visit(@address, Page::Main::Login)
-          Page::Main::Login.perform(&:sign_in_using_admin_credentials)
-          Page::Main::Menu.perform(&:go_to_admin_area)
-          Page::Admin::Menu.perform(&:go_to_network_settings)
-
-          Page::Admin::Settings::Network.perform do |setting|
-            setting.expand_ip_limits do |page|
-              page.enable_throttles
-              page.save_settings
-            end
-          end
-
-          Page::Main::Menu.perform(&:sign_out)
-        end
-
-        def create_personal_access_token
-          signed_in_initially = Page::Main::Menu.perform(&:signed_in?)
-
-          Page::Main::Menu.perform(&:sign_out) if @is_new_session && signed_in_initially
-
-          Flow::Login.sign_in_unless_signed_in(as: @user)
-
-          token = Resource::PersonalAccessToken.fabricate!.access_token
-
-          # If this is a new session, that tests that follow could fail if they
-          # try to sign in without starting a new session.
-          # Also, if the browser wasn't already signed in, leaving it
-          # signed in could cause tests to fail when they try to sign
-          # in again. For example, that would happen if a test has a
-          # before(:context) block that fabricates via the API, and
-          # it's the first test to run so it creates an access token
-          #
-          # Sign out so the tests can successfully sign in
-          Page::Main::Menu.perform(&:sign_out) if @is_new_session || !signed_in_initially
-
-          token
-        end
-      end
-    end
-  end
-end

data/qa/runtime/api/request.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module API
-      class Request
-        API_VERSION = 'v4'.freeze
-
-        def initialize(api_client, path, **query_string)
-          query_string[:private_token] ||= api_client.personal_access_token unless query_string[:oauth_access_token]
-          request_path = request_path(path, **query_string)
-          @session_address = Runtime::Address.new(api_client.address, request_path)
-        end
-
-        def mask_url
-          @session_address.address.sub(/private_token=.*/, "private_token=[****]")
-        end
-
-        def url
-          @session_address.address
-        end
-
-        # Prepend a request path with the path to the API
-        #
-        # path - Path to append
-        #
-        # Examples
-        #
-        #   >> request_path('/issues')
-        #   => "/api/v4/issues"
-        #
-        #   >> request_path('/issues', private_token: 'sometoken)
-        #   => "/api/v4/issues?private_token=..."
-        #
-        # Returns the relative path to the requested API resource
-        def request_path(path, version: API_VERSION, **query_string)
-          full_path = ::File.join('/api', version, path)
-
-          if query_string.any?
-            full_path << (path.include?('?') ? '&' : '?')
-            full_path << query_string.map { |k, v| "#{k}=#{CGI.escape(v)}" }.join('&')
-          end
-
-          full_path
-        end
-      end
-    end
-  end
-end

data/qa/runtime/application_settings.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module ApplicationSettings
-      extend self
-      extend Support::Api
-
-      APPLICATION_SETTINGS_PATH = '/application/settings'
-
-      # Set a GitLab application setting
-      # Example:
-      #   #set({ allow_local_requests_from_web_hooks_and_services: true })
-      #   #set(allow_local_requests_from_web_hooks_and_services: true)
-      # https://docs.gitlab.com/ee/api/settings.html
-      def set_application_settings(**application_settings)
-        QA::Runtime::Logger.info("Setting application settings: #{application_settings}")
-        r = put(Runtime::API::Request.new(api_client, APPLICATION_SETTINGS_PATH).url, **application_settings)
-        raise "Couldn't set application settings #{application_settings.inspect}" unless r.code == QA::Support::Api::HTTP_STATUS_OK
-      end
-
-      def get_application_settings
-        parse_body(get(Runtime::API::Request.new(api_client, APPLICATION_SETTINGS_PATH).url))
-      end
-
-      private
-
-      def api_client
-        @api_client ||= begin
-          return Runtime::API::Client.new(:gitlab, personal_access_token: Runtime::Env.admin_personal_access_token) if Runtime::Env.admin_personal_access_token
-
-          user = Resource::User.fabricate_via_api! do |user|
-            user.username = Runtime::User.admin_username
-            user.password = Runtime::User.admin_password
-          end
-
-          unless user.admin?
-            raise "Administrator access is required to set application settings. User '#{user.username}' is not an administrator."
-          end
-
-          Runtime::API::Client.new(:gitlab, user: user)
-        end
-      end
-    end
-  end
-end