code: def test_sync_container(self, container_type, environment):
      with tmp_context() as tmp:
          key = self.gen_key()
          original_value = fake.unique.word()
          updated_value = fake.unique.word()
  
          with initialize_container(
              container_type=container_type, project=environment.project
          ) as container:
              # assign original value
              container[key] = original_value
              container.wait()
              container_id = container._id
              container_sys_id = container._sys_id
  
              self.stop_synchronization_process(container)
              # add random property - the queue will not be empty on close
              container[self.gen_key()] = fake.unique.word()
  
          # manually add operations to queue
          queue_dir = list(
              Path(
                  f"./.neptune/async/{container_type}__{container_id}/"
              ).glob("exec-*")
          )[0]
          if list(queue_dir.glob("partition-*")):
              queue_dir = list(queue_dir.glob("partition-*"))[0]
          with open(
              queue_dir / "last_put_version", encoding="utf-8"
          ) as last_put_version_f:
              last_put_version = int(last_put_version_f.read())
          with open(
              queue_dir / "data-1.log", "a", encoding="utf-8"
          ) as queue_f:
              queue_f.write(
                  json.dumps(
                      {
                          "obj": {
                              "type": "AssignString",
                              "path": key.split("/"),
                              "value": updated_value,
                          },
                          "version": last_put_version + 1,
                      }
                  )
              )
              queue_f.write(
                  json.dumps(
                      {
                          "obj": {
                              "type": "CopyAttribute",
                              "path": ["copy"] + key.split("/"),
                              "container_id": container_id,
                              "container_type": container_type,
                              "source_path": key.split("/"),
                              "source_attr_name": "String",
                          },
                          "version": last_put_version + 2,
                      }
                  )
              )
          with open(
              queue_dir / "last_put_version", "w", encoding="utf-8"
          ) as last_put_version_f:
              last_put_version_f.write(str(last_put_version + 2))
  
          with reinitialize_container(
              container_sys_id,
              container_type,
              project=environment.project,
              mode="read-only",
          ) as container:
              # server should have the original value
              assert container[key].fetch() == original_value
  
          # run neptune sync
          result = runner.invoke(sync, ["--path", tmp])
          assert result.exit_code == 0
  
          with reinitialize_container(
              container_sys_id,
              container_type,
              project=environment.project,
          ) as container:
              # and we should get the updated value from server
              assert container[key].fetch() == updated_value
              assert container["copy/" + key].fetch() == updated_value
  
imports: import json
  import os
  import re
  from pathlib import Path
  import pytest
  from click.testing import CliRunner
  import neptune
  from neptune.cli import sync
  from neptune.cli.commands import clear
  from neptune.common.exceptions import NeptuneException
  from neptune.types import File
  from tests.e2e.base import AVAILABLE_CONTAINERS, BaseE2ETest, fake
  from tests.e2e.utils import DISABLE_SYSLOG_KWARGS, initialize_container, reinitialize_container, tmp_context
label_desc: Use image node_id 1 for calling the TestSync obj's underlying member method code with example usage: obj.test_sync_container(container_type, environment) without return types