tms-cli 0.0.pre.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 126ea4c79dfe3ba2f0577507e6710dd6a87b54931bd88503ff73f69d87bda43a
+  data.tar.gz: f05c3543997e9f3f9e1452d87e99c1a742abcb6bf2fd2ff5703e93bba947e6ca
+SHA512:
+  metadata.gz: 99d223285e06a2ec541feed40f9b2462c332deedf529944708491736741a815e6b06306cff1f152c9c818b22b5020ee4b3e480a3c189759ba26e3b2ebe6bf3b9
+  data.tar.gz: cf16282634835829b2fdc037c1a0377f290ddf70cf9e5339af5d675dd180f2055b39ae72b76e17aa45bc5e65ffa2f261e021dc19838a2693ea0061569f9aca45

data/bin/tms

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require 'lib/tms'

data/lib/.env

@@ -0,0 +1,11 @@
+TR_USERNAME=core.quality@bukalapak.com
+TR_SECRET=coretebukalapak
+TR_API_KEY=mrVfIsQkG0yhFChoR7j/9r+4GydgMykS7FplZ6/tiXieOIzBKGGRjeI=
+DB_TR_PORT=3306
+DB_TR_USERNAME=usr_testrail_rw
+DB_TR=testrail
+DB_TR_HOST=mysql-tools-prod-testrail-main.mysql.database.azure.com
+DB_TR_PASSWORD=8Z9YJfsUGmSKOnshe6vO/A==
+TR_BASEURL=https://testrail.prod.tools.buka20.com/
+TR_PASSWORD=/rJHEOwcShrdUA==
+BASTION_HOST=bastion.prod.tools.buka20.com

data/lib/cucumber.rb

@@ -0,0 +1,369 @@
+# frozen_string_literal: true
+
+require_relative 'testrail/testrail'
+require_relative 'testrail/milestone'
+require_relative 'testrail/testcase'
+require_relative 'testrail/testrun'
+require_relative 'testrail/dataprep'
+require_relative 'testrail/testsuite'
+require_relative 'testrail/testplan'
+require_relative 'testrail/sections'
+require_relative 'testrail/projects'
+require_relative 'testrail/log'
+require_relative 'testrail/testbdd'
+
+
+module Tms
+  module Cucumber
+    module_function
+
+    include Dataprep
+    include Milestone
+    include Testcase
+    include Testrun
+    include Testsuite
+    include Testplan
+    include Sections
+    include Projects
+    include Log
+    include Testbdd
+  
+    # Create test run cucumber test for micorservice project
+    # @param project name
+    # @param test type (suite)
+    # @param squad name
+    # @param custom label
+    # @param milestone name
+    def create_test_run_microservice(project_name, test_type, squad, label, milestone_name)
+      # getting project id
+      test_type = test_type
+      client = Dataprep.client_tr
+      tr_version = Dataprep.testrail_version(client, ENV['TR_BASEURL'])
+
+      project_id = search_project(client, project_name)
+      puts 'project_id found: ' + project_id.to_s if !project_id.nil?
+
+      milestone_id = Milestone.milestone_id(client, project_id, milestone_name, tr_version)
+      suite_id = search_suite(client, project_id, test_type)
+      case_ids = search_cases(client, project_id, suite_id, squad, label)
+      raise 'no cases found' if case_ids.empty?
+
+      test_run_name = "Test_Run_E2E_#{squad}_#{test_type}"
+      response = Testrun.testrun_id_by_milestone(client, project_id, milestone_id)
+      find_test_run = response.find { |run| run['name'] == test_run_name }
+      run_id = find_test_run&.fetch('id', nil)
+      test_run = run_id.nil? ? Testrun.create_testrun(client, project_id, suite_id, milestone_id, case_ids, test_run_name) : run_id
+
+      getter_testrail_clean_dependencies(test_type, milestone_id, test_run)
+
+      return test_run
+    end
+
+    # Create test run cucumber test for app project
+    # @param project name
+    # @param test type (suite)
+    # @param squad name
+    # @param custom label
+    def create_test_run_app(project_name, squad, env_name, test_type, label, pipeline_id, custom_section)
+      client = Dataprep.client_tr
+      puts project_name.split('_')[1]
+      project_id = app_project_id(project_name)
+      suite_id = search_suite(client, project_id, squad)
+      automation_section_ids = find_automation_section(client, project_id, suite_id, project_name.split('_')[1], env_name, custom_section)
+      case_ids = search_cases_by_section_ids(client, project_id, suite_id, automation_section_ids, label)
+
+      raise 'no cases found' if case_ids.empty?
+
+      test_run_name = "Test_Run_#{squad}_#{test_type}_#{env_name}_#{pipeline_id}"
+      response = Testrun.testrun_id_by_suite(client, project_id, milestone_id = '', suite_id)
+      find_test_run = response.find { |run| run['name'] == test_run_name }
+      run_id = find_test_run&.fetch('id', nil)
+      if run_id.nil?
+        puts "Creating #{test_run_name}..."
+        test_run = Testrun.create_testrun(client, project_id, suite_id, 0, case_ids, test_run_name)
+      else
+        puts "Updating #{test_run_name}..."
+        test_run = Testrun.update_testrun(client, run_id, milestone_id = '', case_ids)
+      end
+
+      getter_testrail_clean_dependencies(test_type, milestone_id = '', test_run)
+
+      return test_run
+    end
+
+    # Find sections of automation test
+    # @param client testrail
+    # @param project id
+    # @param suite id
+    # @param app name
+    # @param environment name
+    def find_automation_section(client, project_id, suite_id, app_name, env_name, custom_section)
+      sections = Sections.get_sections(client, project_id, suite_id)
+      app_section = sections['sections'].find { |section| section['name'].casecmp?(app_name) }
+      automation_section = sections['sections'].find{ |section| 
+        section['name'].casecmp?('automation') && section['parent_id'].eql?(app_section['id'])
+      }
+      
+      env_section = sections['sections'].find{ |section| 
+        section['name'].casecmp?(env_name) && section['parent_id'].eql?(automation_section['id'])
+      }
+      parent_id = env_section['id']
+
+      # search for section directory hierarchy
+      target_section = {}
+      if !custom_section.eql? ""
+        sections_directory = custom_section.split('/')
+        sections_directory.each do | section_dir |
+          target_section = sections['sections'].find { |section|
+            section['name'].casecmp?(section_dir) && section['parent_id'].eql?(parent_id)
+          }
+          parent_id = target_section['id']
+        end
+      else
+        target_section = env_section
+      end
+      
+      related_section_ids = find_related_sections(sections['sections'], target_section['id']) << target_section['id']
+    end
+
+    # Get project id
+    # @param client testrail
+    # @param project id
+    # @param suite id
+    # @param app name
+    # @param environment name
+    def app_project_id(app_name)
+      project = app_name.split("_")
+      platform = project[0]
+      project_ids = {
+        'android' => ENV['TR_ANDROID_PROJECT_ID'],
+        'ios' => ENV['TR_IOS_PROJECT_ID']
+      }
+
+      project_id = project_ids[platform] || (raise 'Incorrect app name!')
+    end
+
+    # Return all case ids from sections and filter with label
+    # @param client testrail
+    # @param project id
+    # @param suite id
+    # @param section_ids
+    # @param label
+    def search_cases_by_section_ids(client, project_id, suite_id, section_ids, label)
+      case_ids = []
+      puts label
+      
+      section_ids.each do |id|
+        cases = Testcase.get_cases(client, project_id, suite_id, id)
+
+          # filter cases with label if any
+          filtered_cases = 
+            if label.eql? '' 
+              cases
+            else 
+              cases.select { |case_data| case_data['custom_label_id']&.include?(label) }
+            end
+            
+          case_ids.concat(filtered_cases.map { |case_data| case_data['id'] })
+        end
+
+      return case_ids
+    end
+
+    # Return project id of a project name
+    # @param client testrail
+    # @param project name
+    def search_project(client, project_name)
+      begin
+        projects = Projects.get_projects(client)
+        filtered_projects = projects.select { |project| project['name'].casecmp?(project_name) }
+        
+        if filtered_projects.empty?
+          puts "#{project_name} is not available!"
+        else
+          return filtered_projects.first['id']
+        end
+        
+      rescue StandardError => e
+        puts "An error occurred: #{e.message}"
+      end
+    end
+
+    # Return suite id of a test type
+    # @param client testrail
+    # @param project id
+    # @param suite name
+    def search_suite(client, project_id, suite_name)
+      begin
+        suites = Testsuite.suites(client, project_id)
+        filtered_suites = suites.select { |suite| suite['name'].casecmp?(suite_name) }
+        
+        if filtered_suites.empty?
+          puts "#{suite_name} is not available!"
+        else
+          return filtered_suites.first['id'] 
+        end
+
+      rescue StandardError => e
+        puts "An error occurred: #{e.message}"
+      end
+    end
+
+    # Return array of case id from a squad section
+    # @param client testrail
+    # @param project id
+    # @param suite id
+    # @param section_name
+    # @param custom label 
+    def search_cases(client, project_id, suite_id, section_name, label)
+      sections = Sections.get_sections(client, project_id, suite_id)
+      squad_section = sections['sections'].find { |section| section['name'].casecmp?(section_name) }
+      raise "squad section #{section_name} not found" if squad_section.eql? nil
+      
+      puts 'squad section: ' + squad_section['id'].to_s
+      # search sections related to the squad section
+      related_sections_ids = find_related_sections(sections['sections'], squad_section['id']) << squad_section['id']
+      puts 'sections related from squad: ' + related_sections_ids.to_s
+
+      case_ids = []
+
+      related_sections_ids.each do |id|
+        cases = Testcase.get_cases(client, project_id, suite_id, id)
+        filtered_cases = []
+
+        if label.split(',').size > 1
+          arr_cases = []
+          label.split(',').each do |i|
+            tmp_filtered_cases = cases.select { |case_data| case_data['custom_label_id']&.include?(i) }
+            arr_cases.concat(tmp_filtered_cases)
+          end
+          filtered_cases = arr_cases
+        else
+          filtered_cases = cases.select { |case_data| case_data['custom_label_id']&.include?(label) }
+        end
+        case_ids.concat(filtered_cases.map { |case_data| case_data['id']})
+
+      end
+
+      return case_ids
+    end
+
+    # Return array of section id related to a parent id
+    # @param array of sections
+    # @param parent id
+    def find_related_sections(sections, parent_id)
+      child_ids = sections
+        .select { |obj| obj['parent_id'] == parent_id }
+        .flat_map { |obj| [obj['id']] + find_related_sections(sections, obj['id']) }
+    
+      child_ids 
+    end
+
+    # Download series of bdd cases from a test run
+    # @aram test run id 
+    def feature_download(run_id)
+      client = Dataprep.client_tr
+      puts 'Get test cases for test run id: ' + run_id.to_s
+      num_test = 0
+      # Create the folder if it doesn't exist
+      folder_path = FileUtils.mkdir_p('scenarios')
+
+      tests = Testrun.test_ids(client, run_id)
+      puts "Downloading #{tests.size} test cases..."
+        tests.each do |test|
+          puts "downloading #{test['title']} feature..."
+          response_data = Testbdd.get_bdd(client, test['case_id'])
+
+          # handle test case with scenario outline included
+          response_data = Testbdd.get_case(client, test['case_id']) if response_data.include? ('Scenario Outline')
+
+          # Append test id as a feature label
+          # Handle if a feature already have labels
+          if response_data[0] == "@"
+            response_data = "@TESTID_#{test['id']} " + response_data
+          else
+            response_data = "@TESTID_#{test['id']}\n " + response_data
+          end
+
+          # Writes the data to a feature file
+          Dataprep.create_file("#{test['case_id']}.feature", folder_path, response_data)
+      end
+    end
+
+    # Download series of bdd cases from a test case directly (without create test run) on microservice
+    # @param project_name
+    # @param suite_name
+    # @param section_name
+    # @param label
+    def micr_download_feature_only(project_name, suite_name, squad, label)
+      client = Dataprep.client_tr
+
+      project_id = search_project(client, project_name)
+      suite_id = search_suite(client, project_id, suite_name)
+      case_ids = search_cases(client, project_id, suite_id, squad, label)
+      raise 'no cases found' if case_ids.empty?
+      
+      download_features_to_local(client, case_ids)
+
+      getter_testrail_clean_dependencies(suite_name, '', '')
+    end
+
+    # Download series of bdd cases from a test case directly (without create test run) on apps
+    # @param project_name
+    # @param suite_name
+    # @param section_name
+    # @param label
+    def app_download_feature_only(project_name, squad, env_name, test_type, label, custom_section)
+      client = Dataprep.client_tr
+      puts project_name.split('_')[1]
+      
+      project_id = app_project_id(project_name)
+      suite_id = search_suite(client, project_id, squad)
+      automation_section_ids = find_automation_section(client, project_id, suite_id, project_name.split('_')[1], env_name, custom_section)
+      case_ids = search_cases_by_section_ids(client, project_id, suite_id, automation_section_ids, label)
+      raise 'no cases found' if case_ids.empty?
+      
+      download_features_to_local(client, case_ids)
+
+      getter_testrail_clean_dependencies(test_type, '', '')
+    end
+
+    # Download test cases to local storaged
+    # @param case_ids
+    def download_features_to_local(client, case_ids)
+      # Create the folder if it doesn't exist
+      folder_path = FileUtils.mkdir_p('scenarios')
+      
+      puts "Download #{case_ids.size} test cases"
+      puts "This test will not create Milestone and Test Runs on Testrail"
+      case_ids.each do |cases|
+        response_data = Testbdd.get_bdd(client, cases)
+
+        # handle test case with scenario outline included
+        response_data = Testbdd.get_case(client, cases) if response_data.include? ('Scenario Outline')
+
+          # Writes the data to a feature file
+          Dataprep.create_file("#{cases}.feature", folder_path, response_data)
+      end
+    end
+
+    def getter_testrail_clean_dependencies(test_type, milestone_id, run_id)
+      test_type_upper = test_type.upcase
+      test_type_final = test_type_upper.gsub(/\s*AUTOMATION\s*/, '')
+      puts "Test Type: #{test_type_final}"
+      # Define your environment variables as a hash
+      env_variables = {
+        "TESTRAIL_TEST_TYPE" => test_type_final,
+        "TESTRAIL_#{test_type_final}_MILESTONE_ID" => milestone_id,
+        "TESTRAIL_#{test_type_final}_RUN_ID" => run_id
+      }
+
+      begin
+        Dataprep.create_file_env("testrail-data-post-test", env_variables)
+      rescue => e
+        puts "Create env failed: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/db/mysql.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative '../../util/script/generate-password'
+require 'mysql2'
+
+module Tms
+  module Database
+    module_function
+
+    include GeneratePassword
+
+     # This method will create client database
+    def connect_db
+      db_host = ENV['DB_TR_HOST']
+      db_port = ENV['DB_TR_PORT']
+      db_user = ENV['DB_TR_USERNAME']
+      db_pass = GeneratePassword.decrypt(ENV['DB_TR_PASSWORD'], ENV['TR_SECRET'])
+      db_name = ENV['DB_TR']
+      Mysql2::Client.new(:host => db_host, :port => db_port, :username => db_user, :password => db_pass, :database => db_name)
+    end
+
+    # This method will validate test runner on database
+    def runner_type(project_id, section_name)
+      test_runner = ''
+      connect_db.query("SELECT runner from runner_type where project_id=#{project_id} and test_type='#{section_name}'").each do |row|
+        test_runner = row['runner']
+      end
+      test_runner
+    end
+
+    # This method will insert test runner if not exist
+    def insert_runner_type(project_id, test_types_and_runner)
+      val = test_types_and_runner.split(',')
+      db_client = connect_db
+      response = db_client.query("SELECT * from runner_type where project_id=#{project_id} and test_type='#{val[0]}' and runner='#{val[1]}'")
+      if response.size.eql?(0)
+        db_client.query("INSERT INTO runner_type(project_id,test_type,runner) VALUE(#{project_id},'#{val[0]}','#{val[1]}');")
+      else
+        Log.info("Test type '#{val[0]}' with runner '#{val[1]}' already exist on project id '#{project_id}'")
+      end
+    end
+
+    # This method will generate config ssh and connect database from local via jump bastion
+    def jump_bastion(email_azure)
+      puts 'connect to vpn buka 2.0 ...' 
+      mysql_prod_host = ENV['DB_TR_HOST']
+      mysql_prod_bastion = ENV['BASTION_HOST']
+      ENV.merge!('DB_TR_HOST' => '127.0.0.1')
+      ENV.merge!('DB_TR_PORT' => '3307')
+      
+      `rm -rf ~/.ssh/id_rsa.pub-aadcert.pub && rm -rf azure-ssh-config`
+      `az ssh cert --public-key-file ~/.ssh/id_rsa.pub`
+      config = "
+      Host vault-core-dev
+        HostName bastion.dev.core.buka20.com
+        LocalForward 8200 vault.dev.core.buka20.com:8200
+    
+      Host vault-core-stg
+        HostName bastion.stg.core.buka20.com
+        LocalForward 8200 vault.stg.core.buka20.com:8200
+      
+      Host vault-core-prod
+        HostName bastion.prod.core.buka20.com
+        LocalForward 8200 vault.prod.core.buka20.com:8200
+      
+      Host vault-o2o-dev
+        HostName bastion.dev.o2o.buka20.com
+        LocalForward 8200 vault.dev.o2o.buka20.com:8200
+      
+      Host vault-o2o-stg
+        HostName bastion.stg.o2o.buka20.com
+        LocalForward 8200 vault.stg.o2o.buka20.com:8200
+      
+      Host vault-o2o-prod
+        HostName bastion.prod.o2o.buka20.com
+        LocalForward 8200 vault.prod.o2o.buka20.com:8200
+      
+      Host vault-tools-stg
+        HostName bastion.stg.tools.buka20.com
+        LocalForward 8200 vault.stg.tools.buka20.com:8200
+      
+      Host vault-tools-prod
+        HostName bastion.prod.tools.buka20.com
+        LocalForward 8200 vault.prod.tools.buka20.com:8200
+        
+      Host *
+        User #{email_azure}
+        CertificateFile ~/.ssh/id_rsa.pub-aadcert.pub
+        StrictHostKeyChecking no
+        UserKnownHostsFile /dev/null"
+
+      ssh_conf_file = File.new("azure_config", "w")
+      ssh_conf_file.puts(config)
+      ssh_conf_file.close
+    
+      `ssh -F azure_config -NL 3307:#{mysql_prod_host}:3306 #{mysql_prod_bastion} & echo $! > ./pid.file & sleep 5`
+    end
+
+    # This method will stop jump bastion for disconnect database from local
+    def stop_jump_bastion
+      puts 'disconnect to vpn buka 2.0 ...' 
+      pid = `cat pid.file`
+      `kill #{pid}`
+      `rm -rf pid.file`
+    end
+  end
+end

data/lib/import/importcucumber.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative '../testrail/testrail'
+require_relative '../testrail/testcase'
+
+module Tms
+  module Cucumber
+    module_function
+
+    include Testcase
+
+    # TODO: Will refer to import_data_bdd instead, after squad migrate test automation to Testrail completely
+    def import_data(client, project_id, suite_id, section_id, report_data_hash, tr_version)
+      # looping the feature
+      report_data_hash.map do |report_data_result|
+        # looping the test cases with get key elements
+        report_data_result['elements'].map do |test_result|
+          # looping the report when keyword is scenario and scenario outline
+          if(test_result['keyword'].downcase == 'scenario' || test_result['keyword'].downcase == 'scenario outline')
+            test_title = test_result['keyword'].downcase == 'scenario outline' ? test_result['id'] : test_result['name']
+            scenario = check_status_and_error_message(test_result['steps'], test_title)
+            test_status = scenario[0]['status']
+
+            # if status is "pending", should get status from object "after" instead
+            # since in cucumber report "pending" turn out as "failed" on summary result
+            if test_status == 'pending'
+              test_status = test_result['after'][0]['result']['status']
+            end
+
+            test_status_id = Testcase.get_status_id(test_status)
+            error_comment = scenario[0]['error_message']
+            refs = get_refs_id(test_result['tags']) || ''
+
+            Testcase.validate_testcase(client, section_id, test_title, test_status_id, refs, tr_version, error_comment)
+          end
+        end
+      end
+    end
+
+    def import_data_bdd(client, project_id, suite_id, section_id, report_data_hash, tr_version)
+      # looping the feature
+      report_data_hash.map do |report_data_result|
+        # looping the test cases with get key elements
+        report_data_result['elements'].map do |test_result|
+          # looping the report when keyword is scenario and scenario outline
+          if(test_result['keyword'].downcase == 'scenario' || test_result['keyword'].downcase == 'scenario outline')
+            test_title = test_result['keyword'].downcase == 'scenario outline' ? test_result['id'] : test_result['name']
+            scenario = check_status_and_error_message(test_result['steps'], test_title)
+            labels = test_result['tags'][0]['name']
+            test_status = scenario[0]['status']
+
+            test_status_id = Testcase.get_status_id(test_status)
+            error_comment = scenario[0]['error_message']
+            refs = get_refs_id(test_result['tags']) || ''
+
+            if labels.include?('@TESTID_')
+              test_id = labels.gsub('@TESTID_','')
+              Results.add_result(client, test_id, test_status_id, error_comment)
+            end
+            Testcase.validate_testcase_bdd(client, section_id, test_id, refs, tr_version)
+          end
+        end
+      end
+    end
+
+    def check_status_and_error_message(steps, test_title)
+      result_scenario = []
+      isSuccess = true
+      error_message = ''
+      test_result = {}
+      list_status = ['passed', 'skipped', 'failed', 'undefined', 'pending']
+      
+      #looping each steps in scenario
+      steps.map do |scenario|
+        status = scenario['result']['status']
+        # check if status failed or skipped then save the status failed and pending and not continue the looping
+        # save the status and error message
+        # if failed then get the error message from json and if skipped then the error message will be empty
+        if list_status.include?(status)
+          if status.downcase == 'failed' || status.downcase == 'undefined' || status.downcase == 'skipped'
+            isSuccess = false
+            error_message = scenario['result']['error_message'] || ''
+            test_result['status']= 'failed'
+            test_result['error_message']= error_message
+            break
+          end
+        else
+          puts "invalid status is in test case with title = #{test_title}"
+          puts "status = #{status}"
+          isSuccess = false
+          test_result['status'] = 'invalid status'
+          test_result['error_message'] = error_message
+          break
+        end
+      end
+
+      # after looping all the steps if there is no failed and skipeed then the status will be passed and error message will be empty
+      if isSuccess == true
+        test_result['status'] = 'passed'
+        test_result['error_message'] = error_message
+      end
+    
+      return result_scenario.push(test_result)
+    end
+
+    def get_refs_id(elements)
+      jira_id = ''
+
+      # looping the tag element and find prefix @TEST or @CUCUMBER
+      elements.map do |element|
+        tag = element['name']
+        if tag.include?("@TEST_") || tag.include?("@CUCUMBER_")
+          # split the tag name with _ and save the value on index 1 that have value of JIRA ID
+          array_jira_id = tag.split("_")
+          jira_id = array_jira_id[1]
+          break
+        end
+      end
+      return jira_id
+    end
+
+  end
+end

data/lib/import/importfeature.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '../testrail/testrail'
+
+module Tms
+  module Feature
+    module_function
+
+    def parsing_feature(file)
+      updated_bdd_scenario = ''
+      feature_file = File.read(file)
+
+      bdd_refs = feature_file.lines.first.scan(/@[\w-]+/).join(',').gsub('@','')
+
+      # Extract test title from local file
+      bdd_title = feature_file.match(/Feature:(.+)/)[1]
+      # Extract custom label and BDD scenario from local file
+      bdd_label = feature_file.match(/Feature:.+?\n\s*(.+?)\n/m)[1].scan(/@\S+/).join(' ')
+      bdd_scenario = bdd_label + "\n" + feature_file.match(/(?:Scenario Outline|Scenario):(.+?)(?=Scenario(?:Outline|:)|\z)/m)[0]
+
+      [bdd_refs, bdd_title, bdd_label, bdd_scenario]
+    end
+
+    def update_bdd(client, case_id, file)
+      bdd_refs, bdd_title, bdd_label, bdd_scenario = parsing_feature(file)
+      Testcase.update_case(client, case_id, bdd_refs, bdd_title, bdd_label, bdd_scenario)
+    end
+
+    def add_case(client, section_id, file)
+      bdd_refs, bdd_title, bdd_label, bdd_scenario = parsing_feature(file)
+      Testcase.add_case(client, section_id, bdd_refs, bdd_title, bdd_label, bdd_scenario)
+    end
+
+  end
+end