github.com/lingyao2333/mo-zero@v1.4.1/core/stores/mon/model_test.go (about)

     1  package mon
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"go.mongodb.org/mongo-driver/bson"
     9  	"go.mongodb.org/mongo-driver/mongo"
    10  	"go.mongodb.org/mongo-driver/mongo/integration/mtest"
    11  )
    12  
    13  func TestModel_StartSession(t *testing.T) {
    14  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
    15  	defer mt.Close()
    16  
    17  	mt.Run("test", func(mt *mtest.T) {
    18  		m := createModel(mt)
    19  		sess, err := m.StartSession()
    20  		assert.Nil(t, err)
    21  		defer sess.EndSession(context.Background())
    22  
    23  		_, err = sess.WithTransaction(context.Background(), func(sessCtx mongo.SessionContext) (interface{}, error) {
    24  			_ = sessCtx.StartTransaction()
    25  			sessCtx.Client().Database("1")
    26  			sessCtx.EndSession(context.Background())
    27  			return nil, nil
    28  		})
    29  		assert.Nil(t, err)
    30  		assert.NoError(t, sess.CommitTransaction(context.Background()))
    31  		assert.Error(t, sess.AbortTransaction(context.Background()))
    32  	})
    33  }
    34  
    35  func TestModel_Aggregate(t *testing.T) {
    36  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
    37  	defer mt.Close()
    38  
    39  	mt.Run("test", func(mt *mtest.T) {
    40  		m := createModel(mt)
    41  		find := mtest.CreateCursorResponse(
    42  			1,
    43  			"DBName.CollectionName",
    44  			mtest.FirstBatch,
    45  			bson.D{
    46  				{Key: "name", Value: "John"},
    47  			})
    48  		getMore := mtest.CreateCursorResponse(
    49  			1,
    50  			"DBName.CollectionName",
    51  			mtest.NextBatch,
    52  			bson.D{
    53  				{Key: "name", Value: "Mary"},
    54  			})
    55  		killCursors := mtest.CreateCursorResponse(
    56  			0,
    57  			"DBName.CollectionName",
    58  			mtest.NextBatch)
    59  		mt.AddMockResponses(find, getMore, killCursors)
    60  		var result []interface{}
    61  		err := m.Aggregate(context.Background(), &result, mongo.Pipeline{})
    62  		assert.Nil(t, err)
    63  		assert.Equal(t, 2, len(result))
    64  		assert.Equal(t, "John", result[0].(bson.D).Map()["name"])
    65  		assert.Equal(t, "Mary", result[1].(bson.D).Map()["name"])
    66  
    67  		triggerBreaker(m)
    68  		assert.Equal(t, errDummy, m.Aggregate(context.Background(), &result, mongo.Pipeline{}))
    69  	})
    70  }
    71  
    72  func TestModel_DeleteMany(t *testing.T) {
    73  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
    74  	defer mt.Close()
    75  
    76  	mt.Run("test", func(mt *mtest.T) {
    77  		m := createModel(mt)
    78  		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "n", Value: 1}}...))
    79  		val, err := m.DeleteMany(context.Background(), bson.D{})
    80  		assert.Nil(t, err)
    81  		assert.Equal(t, int64(1), val)
    82  
    83  		triggerBreaker(m)
    84  		_, err = m.DeleteMany(context.Background(), bson.D{})
    85  		assert.Equal(t, errDummy, err)
    86  	})
    87  }
    88  
    89  func TestModel_DeleteOne(t *testing.T) {
    90  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
    91  	defer mt.Close()
    92  
    93  	mt.Run("test", func(mt *mtest.T) {
    94  		m := createModel(mt)
    95  		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "n", Value: 1}}...))
    96  		val, err := m.DeleteOne(context.Background(), bson.D{})
    97  		assert.Nil(t, err)
    98  		assert.Equal(t, int64(1), val)
    99  
   100  		triggerBreaker(m)
   101  		_, err = m.DeleteOne(context.Background(), bson.D{})
   102  		assert.Equal(t, errDummy, err)
   103  	})
   104  }
   105  
   106  func TestModel_Find(t *testing.T) {
   107  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
   108  	defer mt.Close()
   109  
   110  	mt.Run("test", func(mt *mtest.T) {
   111  		m := createModel(mt)
   112  		find := mtest.CreateCursorResponse(
   113  			1,
   114  			"DBName.CollectionName",
   115  			mtest.FirstBatch,
   116  			bson.D{
   117  				{Key: "name", Value: "John"},
   118  			})
   119  		getMore := mtest.CreateCursorResponse(
   120  			1,
   121  			"DBName.CollectionName",
   122  			mtest.NextBatch,
   123  			bson.D{
   124  				{Key: "name", Value: "Mary"},
   125  			})
   126  		killCursors := mtest.CreateCursorResponse(
   127  			0,
   128  			"DBName.CollectionName",
   129  			mtest.NextBatch)
   130  		mt.AddMockResponses(find, getMore, killCursors)
   131  		var result []interface{}
   132  		err := m.Find(context.Background(), &result, bson.D{})
   133  		assert.Nil(t, err)
   134  		assert.Equal(t, 2, len(result))
   135  		assert.Equal(t, "John", result[0].(bson.D).Map()["name"])
   136  		assert.Equal(t, "Mary", result[1].(bson.D).Map()["name"])
   137  
   138  		triggerBreaker(m)
   139  		assert.Equal(t, errDummy, m.Find(context.Background(), &result, bson.D{}))
   140  	})
   141  }
   142  
   143  func TestModel_FindOne(t *testing.T) {
   144  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
   145  	defer mt.Close()
   146  
   147  	mt.Run("test", func(mt *mtest.T) {
   148  		m := createModel(mt)
   149  		find := mtest.CreateCursorResponse(
   150  			1,
   151  			"DBName.CollectionName",
   152  			mtest.FirstBatch,
   153  			bson.D{
   154  				{Key: "name", Value: "John"},
   155  			})
   156  		killCursors := mtest.CreateCursorResponse(
   157  			0,
   158  			"DBName.CollectionName",
   159  			mtest.NextBatch)
   160  		mt.AddMockResponses(find, killCursors)
   161  		var result bson.D
   162  		err := m.FindOne(context.Background(), &result, bson.D{})
   163  		assert.Nil(t, err)
   164  		assert.Equal(t, "John", result.Map()["name"])
   165  
   166  		triggerBreaker(m)
   167  		assert.Equal(t, errDummy, m.FindOne(context.Background(), &result, bson.D{}))
   168  	})
   169  }
   170  
   171  func TestModel_FindOneAndDelete(t *testing.T) {
   172  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
   173  	defer mt.Close()
   174  
   175  	mt.Run("test", func(mt *mtest.T) {
   176  		m := createModel(mt)
   177  		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
   178  			{Key: "value", Value: bson.D{{Key: "name", Value: "John"}}},
   179  		}...))
   180  		var result bson.D
   181  		err := m.FindOneAndDelete(context.Background(), &result, bson.D{})
   182  		assert.Nil(t, err)
   183  		assert.Equal(t, "John", result.Map()["name"])
   184  
   185  		triggerBreaker(m)
   186  		assert.Equal(t, errDummy, m.FindOneAndDelete(context.Background(), &result, bson.D{}))
   187  	})
   188  }
   189  
   190  func TestModel_FindOneAndReplace(t *testing.T) {
   191  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
   192  	defer mt.Close()
   193  
   194  	mt.Run("test", func(mt *mtest.T) {
   195  		m := createModel(mt)
   196  		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
   197  			{Key: "value", Value: bson.D{{Key: "name", Value: "John"}}},
   198  		}...))
   199  		var result bson.D
   200  		err := m.FindOneAndReplace(context.Background(), &result, bson.D{}, bson.D{
   201  			{Key: "name", Value: "Mary"},
   202  		})
   203  		assert.Nil(t, err)
   204  		assert.Equal(t, "John", result.Map()["name"])
   205  
   206  		triggerBreaker(m)
   207  		assert.Equal(t, errDummy, m.FindOneAndReplace(context.Background(), &result, bson.D{}, bson.D{
   208  			{Key: "name", Value: "Mary"},
   209  		}))
   210  	})
   211  }
   212  
   213  func TestModel_FindOneAndUpdate(t *testing.T) {
   214  	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
   215  	defer mt.Close()
   216  
   217  	mt.Run("test", func(mt *mtest.T) {
   218  		m := createModel(mt)
   219  		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
   220  			{Key: "value", Value: bson.D{{Key: "name", Value: "John"}}},
   221  		}...))
   222  		var result bson.D
   223  		err := m.FindOneAndUpdate(context.Background(), &result, bson.D{}, bson.D{
   224  			{Key: "$set", Value: bson.D{{Key: "name", Value: "Mary"}}},
   225  		})
   226  		assert.Nil(t, err)
   227  		assert.Equal(t, "John", result.Map()["name"])
   228  
   229  		triggerBreaker(m)
   230  		assert.Equal(t, errDummy, m.FindOneAndUpdate(context.Background(), &result, bson.D{}, bson.D{
   231  			{Key: "$set", Value: bson.D{{Key: "name", Value: "Mary"}}},
   232  		}))
   233  	})
   234  }
   235  
   236  func createModel(mt *mtest.T) *Model {
   237  	Inject(mt.Name(), mt.Client)
   238  	return MustNewModel(mt.Name(), mt.DB.Name(), mt.Coll.Name())
   239  }
   240  
   241  func triggerBreaker(m *Model) {
   242  	m.Collection.(*decoratedCollection).brk = new(dropBreaker)
   243  }