github.com/etecs-ru/gnomock@v0.13.2/sdktest/python/test/test_sdk.py (about)

     1  import gnomock
     2  from gnomock.api.presets_api import PresetsApi
     3  from gnomock.model.options import Options
     4  
     5  from gnomock.model.localstack import Localstack
     6  from gnomock.model.localstack_request import LocalstackRequest
     7  
     8  from gnomock.model.splunk import Splunk
     9  from gnomock.model.splunk_request import SplunkRequest
    10  
    11  from gnomock.model.mongo import Mongo
    12  from gnomock.model.mongo_request import MongoRequest
    13  
    14  from gnomock.model.mysql import Mysql
    15  from gnomock.model.mysql_request import MysqlRequest
    16  
    17  from gnomock.model.mariadb import Mariadb
    18  from gnomock.model.mariadb_request import MariadbRequest
    19  
    20  from gnomock.model.mssql import Mssql
    21  from gnomock.model.mssql_request import MssqlRequest
    22  
    23  from gnomock.model.postgres import Postgres
    24  from gnomock.model.postgres_request import PostgresRequest
    25  
    26  from gnomock.model.cockroachdb import Cockroachdb
    27  from gnomock.model.cockroachdb_request import CockroachdbRequest
    28  
    29  from gnomock.model.elastic import Elastic
    30  from gnomock.model.elastic_request import ElasticRequest
    31  
    32  from gnomock.model.redis import Redis
    33  from gnomock.model.redis_request import RedisRequest
    34  
    35  from gnomock.model.memcached import Memcached
    36  from gnomock.model.memcached_request import MemcachedRequest
    37  
    38  from gnomock.model.rabbitmq import Rabbitmq
    39  from gnomock.model.rabbitmq_request import RabbitmqRequest
    40  from gnomock.model.rabbitmq_message import RabbitmqMessage
    41  
    42  from gnomock.model.kubernetes import Kubernetes
    43  from gnomock.model.kubernetes_request import KubernetesRequest
    44  
    45  from gnomock.model.kafka import Kafka
    46  from gnomock.model.kafka_request import KafkaRequest
    47  from gnomock.model.kafka_messages import KafkaMessages
    48  
    49  from gnomock.model.stop_request import StopRequest
    50  
    51  import unittest
    52  import os
    53  
    54  
    55  class TestSDK(unittest.TestCase):
    56      def setUp(self):
    57          with gnomock.ApiClient() as client:
    58              self.api = PresetsApi(client)
    59  
    60      def tearDown(self):
    61          return super().tearDown()
    62  
    63      def test_mongo(self):
    64          options = Options()
    65          file_name = os.path.abspath("./test/testdata/mongo")
    66          preset = Mongo(data_path=file_name, version="3")
    67          mongo_request = MongoRequest(options=options, preset=preset)
    68          id_candidate = ""
    69  
    70          try:
    71              response = self.api.start_mongo(mongo_request)
    72              id_candidate = response.id
    73              self.assertEqual("127.0.0.1", response.host)
    74  
    75          finally:
    76              if id_candidate != "":
    77                  stop_request = StopRequest(id=id_candidate)
    78                  self.api.stop(stop_request)
    79  
    80      def test_mysql(self):
    81          options = Options()
    82          file_name = os.path.abspath("./test/testdata/mysql/schema.sql")
    83          preset = Mysql(queries_files=[file_name], version="8")
    84          mysql_request = MysqlRequest(options=options, preset=preset)
    85          id_candidate = ""
    86  
    87          try:
    88              response = self.api.start_mysql(mysql_request)
    89              id_candidate = response.id
    90              self.assertEqual("127.0.0.1", response.host)
    91  
    92          finally:
    93              if id != "":
    94                  stop_request = StopRequest(id=id_candidate)
    95                  self.api.stop(stop_request)
    96  
    97      def test_mariadb(self):
    98          options = Options()
    99          file_name = os.path.abspath("./test/testdata/mysql/schema.sql")
   100          preset = Mariadb(queries_files=[file_name], version="10")
   101          mariadb_request = MariadbRequest(options=options, preset=preset)
   102          id_candidate = ""
   103  
   104          try:
   105              response = self.api.start_mariadb(mariadb_request)
   106              id_candidate = response.id
   107              self.assertEqual("127.0.0.1", response.host)
   108  
   109          finally:
   110              if id != "":
   111                  stop_request = StopRequest(id=id_candidate)
   112                  self.api.stop(stop_request)
   113  
   114      def test_mssql(self):
   115          options = Options()
   116          file_name = os.path.abspath("./test/testdata/mssql/schema.sql")
   117          preset = Mssql(queries_files=[file_name], license=True, version="2019-latest")
   118          mssql_request = MssqlRequest(options=options, preset=preset)
   119          id_candidate = ""
   120  
   121          try:
   122              response = self.api.start_mssql(mssql_request)
   123              id_candidate = response.id
   124              self.assertEqual("127.0.0.1", response.host)
   125  
   126          finally:
   127              if id_candidate != "":
   128                  stop_request = StopRequest(id=id_candidate)
   129                  self.api.stop(stop_request)
   130  
   131      def test_postgres(self):
   132          options = Options()
   133          file_name = os.path.abspath("./test/testdata/postgres/schema.sql")
   134          preset = Postgres(queries_files=[file_name], version="12")
   135          postgres_request = PostgresRequest(options=options, preset=preset)
   136          id_candidate = ""
   137  
   138          try:
   139              response = self.api.start_postgres(postgres_request)
   140              id_candidate = response.id
   141              self.assertEqual("127.0.0.1", response.host)
   142  
   143          finally:
   144              if id_candidate != "":
   145                  stop_request = StopRequest(id=id_candidate)
   146                  self.api.stop(stop_request)
   147  
   148      def test_redis(self):
   149          options = Options(debug=True)
   150          values = {
   151              "foo": "bar",
   152              "number": 42,
   153              "float": 3.14
   154          }
   155          preset = Redis(version="5", values=values)
   156          redis_request = RedisRequest(options=options, preset=preset)
   157          id_candidate = ""
   158  
   159          try:
   160              response = self.api.start_redis(redis_request)
   161              id_candidate = response.id
   162              self.assertEqual("127.0.0.1", response.host)
   163  
   164          finally:
   165              if id_candidate != "":
   166                  stop_request = StopRequest(id=id_candidate)
   167                  self.api.stop(stop_request)
   168  
   169      def test_memcached(self):
   170          options = Options()
   171          values = {
   172              "foo": "bar",
   173          }
   174          byte_values = {
   175              "key": "Z25vbW9jawo="
   176          }
   177          preset = Memcached(version="1.6.9-alpine", values=values,
   178                             byte_values=byte_values)
   179          memcached_request = MemcachedRequest(options=options, preset=preset)
   180          id_candidate = ""
   181  
   182          try:
   183              response = self.api.start_memcached(memcached_request)
   184              id_candidate = response.id
   185              self.assertEqual("127.0.0.1", response.host)
   186  
   187          finally:
   188              if id_candidate != "":
   189                  stop_request = StopRequest(id=id_candidate)
   190                  self.api.stop(stop_request)
   191  
   192      def test_splunk(self):
   193          options = Options()
   194          file_name = os.path.abspath("./test/testdata/splunk/events.jsonl")
   195          preset = Splunk(values_file=file_name, accept_license=True,
   196                          admin_password="12345678", version="8.0.2.1")
   197          splunk_request = SplunkRequest(options=options, preset=preset)
   198          id_candidate = ""
   199  
   200          try:
   201              response = self.api.start_splunk(splunk_request)
   202              id_candidate = response.id
   203              self.assertEqual("127.0.0.1", response.host)
   204  
   205          finally:
   206              if id_candidate != "":
   207                  stop_request = StopRequest(id=id_candidate)
   208                  self.api.stop(stop_request)
   209  
   210      def test_localstack(self):
   211          options = Options()
   212          preset = Localstack(services=['s3'], version="0.12.9")
   213          localstack_request = LocalstackRequest(options=options, preset=preset)
   214          id_candidate = ""
   215  
   216          try:
   217              response = self.api.start_localstack(localstack_request)
   218              id_candidate = response.id
   219              self.assertEqual("127.0.0.1", response.host)
   220  
   221          finally:
   222              if id_candidate != "":
   223                  stop_request = StopRequest(id=id_candidate)
   224                  self.api.stop(stop_request)
   225  
   226      def test_rabbitmq(self):
   227          file_name = os.path.abspath("./test/testdata/rabbitmq/messages.jsonl")
   228          options = Options()
   229          message = RabbitmqMessage(queue="alerts",
   230                                    content_type="text/plain", string_body="python")
   231          preset = Rabbitmq(version="3.8.14-alpine",
   232                            messages_files=[file_name], messages=[message])
   233          rabbitmq_request = RabbitmqRequest(options=options,
   234                                             preset=preset)
   235          id_candidate = ""
   236  
   237          try:
   238              response = self.api.start_rabbit_mq(rabbitmq_request)
   239              id_candidate = response.id
   240              self.assertEqual("127.0.0.1", response.host)
   241  
   242          finally:
   243              if id_candidate != "":
   244                  stop_request = StopRequest(id=id_candidate)
   245                  self.api.stop(stop_request)
   246  
   247      def test_kafka(self):
   248          options = Options()
   249          preset = Kafka(version="2.5.1-L1")
   250          kafka_request = KafkaRequest(options=options,
   251                                       preset=preset)
   252          id_candidate = ""
   253  
   254          try:
   255              response = self.api.start_kafka(kafka_request)
   256              id_candidate = response.id
   257              self.assertEqual("127.0.0.1", response.host)
   258  
   259          finally:
   260              if id != "":
   261                  stop_request = StopRequest(id=id_candidate)
   262                  self.api.stop(stop_request)
   263  
   264      def test_elastic(self):
   265          options = Options()
   266          preset = Elastic(version="7.12.0")
   267          elastic_request = ElasticRequest(options=options,
   268                                           preset=preset)
   269          id_candidate = ""
   270  
   271          try:
   272              response = self.api.start_elastic(elastic_request)
   273              id_candidate = response.id
   274              self.assertEqual("127.0.0.1", response.host)
   275  
   276          finally:
   277              if id_candidate != "":
   278                  stop_request = StopRequest(id=id_candidate)
   279                  self.api.stop(stop_request)
   280  
   281      def test_kubernetes(self):
   282          options = Options()
   283          preset = Kubernetes(version="latest")
   284          kubernetes_request = KubernetesRequest(options=options,
   285                                                 preset=preset)
   286          id_candidate = ""
   287  
   288          try:
   289              response = self.api.start_kubernetes(kubernetes_request)
   290              id_candidate = response.id
   291              self.assertEqual("127.0.0.1", response.host)
   292  
   293          finally:
   294              if id_candidate != "":
   295                  stop_request = StopRequest(id=id_candidate)
   296                  self.api.stop(stop_request)
   297  
   298      def test_cockroachdb(self):
   299          options = Options()
   300          preset = Cockroachdb(version="v20.2.7")
   301          cockroachdb_request = CockroachdbRequest(options=options,
   302                                                   preset=preset)
   303          id_candidate = ""
   304  
   305          try:
   306              response = self.api.start_cockroach_db(cockroachdb_request)
   307              id_candidate = response.id
   308              self.assertEqual("127.0.0.1", response.host)
   309  
   310          finally:
   311              if id_candidate != "":
   312                  stop_request = StopRequest(id=id_candidate)
   313                  self.api.stop(stop_request)
   314  
   315  # gnomock-generator
   316  
   317  
   318  if __name__ == "__main__":
   319      unittest.main()