public void TestRegisterNewUser() { RunAndAwait(() => { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomNotRegisteredUser(); string propertyKey = "property_key#" + Random.Next(); string propertyValue = "property_value#" + Random.Next(); user.SetProperty(propertyKey, propertyValue); Backendless.UserService.Register(user, new ResponseCallback <BackendlessUser>(this) { ResponseHandler = response => { UsedProperties.Add(propertyKey); Assert.IsNotNull(response.GetProperty("id"), "UserService.register didn't set user ID"); foreach (String key in user.Properties.Keys) { Assert.IsTrue(response.Properties.ContainsKey(key), "Registered user didn`t contain expected property " + key); Assert.AreEqual(user.GetProperty(key), response.GetProperty(key), "UserService.register changed property " + key); } CountDown(); } }); }); }
public void TestCurrentUserAfterLogin() { try { BackendlessUser notRegisteredUseruser = GetRandomNotRegisteredUser(); string propertyKey = "propertykey" + Random.Next(); string propertyValue = "property_value#" + Random.Next(); notRegisteredUseruser.SetProperty(propertyKey, propertyValue); BackendlessUser user = Backendless.UserService.Register(notRegisteredUseruser); UsedProperties.Add(propertyKey); user = Backendless.UserService.Login((string)user.GetProperty(LOGIN_KEY), user.Password); Assert.IsNotNull(Backendless.UserService.CurrentUser, "Current user was null"); foreach (string key in user.Properties.Keys) { if (key.Equals("password")) { continue; } Assert.IsTrue(Backendless.UserService.CurrentUser.Properties.ContainsKey(key), "Current user didn`t contain expected property " + key); Assert.AreEqual(user.GetProperty(key), Backendless.UserService.CurrentUser.GetProperty(key), "UserService.register changed property " + key); } } catch (System.Exception t) { Assert.Fail(t.Message); } }
public void TestUpdateUserForVersionWithEnabledDynamicPropertis() { RunAndAwait(() => { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, Defaults.TEST_VERSION); GetRandomLoggedInUser(new ResponseCallback <BackendlessUser>(this) { ResponseHandler = user => { string propertyKey = "somePropertyKey" + Random.Next(); string propertyValue = "somePropertyValue" + Random.Next(); user.SetProperty(propertyKey, propertyValue); foreach (String usedProperty in UsedProperties) { user.SetProperty(usedProperty, "someValue"); } Backendless.UserService.Update(user, new ResponseCallback <BackendlessUser>(this) { ResponseHandler = response => { UsedProperties.Add(propertyKey); Backendless.UserService.Login(response.Email, response.Password); Backendless.UserService.DescribeUserClass( new ResponseCallback <List <UserProperty> >(this) { ResponseHandler = userProperties => { Assert.IsNotNull(userProperties, "Server returned null user properties"); Assert.IsTrue(userProperties.Count != 0, "Server returned empty user properties"); bool flag = false; foreach (UserProperty userProperty in userProperties) { if (userProperty.Name.Equals(propertyKey)) { flag = true; Assert.IsTrue( userProperty.Type.Equals(DateTypeEnum.STRING), "Property had wrong type"); } } Assert.IsTrue(flag, "Expected property was not found"); CountDown(); } }); } }); } }); }); }
// ---------------------------------------------------------------------------------------- /// <summary> /// /// </summary> /// <typeparam name="TProperty">property type</typeparam> /// <param name="expression">a lambda expression of the type s => s.PropertyName</param> /// <returns>if this property is populated</returns> protected bool IsUsedProperty<TProperty>(Expression<Func<TStepRow, TProperty>> expression) { var uses = false; var memberExpression = expression.Body as MemberExpression; // ReSharper disable once InvertIf if (memberExpression != null && memberExpression.Member.MemberType == MemberTypes.Property) { var sPropertyName = memberExpression.Member.Name; uses = (UsedProperties.Contains(sPropertyName)); } return uses; }
public void TestCurrentUserAfterLogin() { RunAndAwait(() => { BackendlessUser notRegisteredUseruser = GetRandomNotRegisteredUser(); string propertyKey = "propertykey" + Random.Next(); string propertyValue = "property_value#" + Random.Next(); notRegisteredUseruser.SetProperty(propertyKey, propertyValue); Backendless.UserService.Register(notRegisteredUseruser, new ResponseCallback <BackendlessUser>(this) { ResponseHandler = response => { UsedProperties.Add(propertyKey); Backendless.UserService.Login( (string)response.GetProperty(LOGIN_KEY), response.Password, new ResponseCallback <BackendlessUser>(this) { ResponseHandler = user => { Assert.IsNotNull(Backendless.UserService.CurrentUser, "Current user was null"); foreach (string key in user.Properties.Keys) { if (key.Equals("password")) { continue; } Assert.IsTrue( Backendless.UserService.CurrentUser.Properties.ContainsKey( key), "Current user didn`t contain expected property " + key); Assert.AreEqual(user.GetProperty(key), Backendless.UserService.CurrentUser .GetProperty(key), "UserService.register changed property " + key); } CountDown(); } }); } }); }); }
public void TestRegisterNewUser() { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomNotRegisteredUser(); String propertyKey = "property_key#" + Random.Next(); String propertyValue = "property_value#" + Random.Next(); user.SetProperty(propertyKey, propertyValue); BackendlessUser registeredUser = Backendless.UserService.Register(user); UsedProperties.Add(propertyKey); Assert.IsNotNull(registeredUser.GetProperty("id"), "UserService.register didn't set user ID"); foreach (string key in user.Properties.Keys) { Assert.IsTrue(registeredUser.Properties.ContainsKey(key), "Registered user didn`t contain expected property " + key); Assert.AreEqual(user.GetProperty(key), registeredUser.GetProperty(key), "UserService.register changed property " + key); } }
public void TestUpdateUserForVersionWithEnabledDynamicPropertis() { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomLoggedInUser(); string propertyKey = "somePropertyKey" + Random.Next(); string propertyValue = "somePropertyValue" + Random.Next(); user.SetProperty(propertyKey, propertyValue); foreach (string usedProperty in UsedProperties) { user.SetProperty(usedProperty, "someValue"); } Backendless.UserService.Update(user); UsedProperties.Add(propertyKey); List <UserProperty> userProperties = Backendless.UserService.DescribeUserClass(); Assert.IsNotNull(userProperties, "Server returned null user properties"); Assert.IsTrue(userProperties.Count != 0, "Server returned empty user properties"); bool flag = false; foreach (UserProperty userProperty in userProperties) { if (userProperty.Name.Equals(propertyKey)) { flag = true; Assert.IsTrue(userProperty.Type.Equals(DateTypeEnum.STRING), "Property had wrong type") ; } } Assert.IsTrue(flag, "Expected property was not found"); }
// ---------------------------------------------------------------------------------------- /// <summary> /// use reflection to perform the check for valid fields in the DERIVED class /// </summary> /// <param name="other">the other instance with which to compare</param> protected bool HelperEquals(TStepRow other) { var type = typeof(TStepRow); other.Should().NotBeNull(Resources.StepRow_EqualsOverrideNullMessage); var equals = true; // ReSharper disable once InvertIf if (!ReferenceEquals(this, other)) { // ReSharper disable once PossibleNullReferenceException var usedProperties = UsedProperties.Union(other.UsedProperties).ToList(); foreach (var propertyName in usedProperties) { var propertyInfo = type.GetProperty(propertyName); // this should perform a check against the type, not the object dynamic thisValue = propertyInfo.GetValue(this, null); dynamic otherValue = propertyInfo.GetValue(other, null); var isCollection = propertyInfo.PropertyType.IsConstructedGenericType && typeof(IEnumerable).IsAssignableFrom(propertyInfo.PropertyType); if (!isCollection) { equals = (thisValue == otherValue); if (!equals) break; } else // check that the collections' contents are equal { var bothNull = (thisValue == null && otherValue == null); var bothNotNull = (thisValue != null && otherValue != null); equals = bothNull || bothNotNull; if (!equals) break; if (bothNull) break; // ReSharper disable PossibleNullReferenceException equals = (thisValue.Count == otherValue.Count); // ReSharper restore PossibleNullReferenceException if (!equals) break; //equals = Enumerable.SequenceEqual(thisValue, otherValue); //if (!equals) break; for (var index = 0; index < thisValue.Count; ++index) { equals = (otherValue.Contains(thisValue[index])); if (!equals) break; } if (!equals) break; for (var index = 0; index < otherValue.Count; ++index) { equals = (thisValue.Contains(otherValue[index])); if (!equals) break; } if (!equals) break; } } } return equals; }
/// <summary> /// Gets the hash code /// </summary> /// <returns>Hash code</returns> public override int GetHashCode() { unchecked // Overflow is fine, just wrap { var hashCode = 41; // Suitable nullity checks etc, of course :) if (PathDescField != null) { hashCode = hashCode * 59 + PathDescField.GetHashCode(); } if (PathChildField != null) { hashCode = hashCode * 59 + PathChildField.GetHashCode(); } if (PathParentField != null) { hashCode = hashCode * 59 + PathParentField.GetHashCode(); } if (PathExactField != null) { hashCode = hashCode * 59 + PathExactField.GetHashCode(); } if (CatchAllField != null) { hashCode = hashCode * 59 + CatchAllField.GetHashCode(); } if (CollapsedPathField != null) { hashCode = hashCode * 59 + CollapsedPathField.GetHashCode(); } if (PathDepthField != null) { hashCode = hashCode * 59 + PathDepthField.GetHashCode(); } if (CommitPolicy != null) { hashCode = hashCode * 59 + CommitPolicy.GetHashCode(); } if (Rows != null) { hashCode = hashCode * 59 + Rows.GetHashCode(); } if (PathRestrictions != null) { hashCode = hashCode * 59 + PathRestrictions.GetHashCode(); } if (PropertyRestrictions != null) { hashCode = hashCode * 59 + PropertyRestrictions.GetHashCode(); } if (PrimarytypesRestrictions != null) { hashCode = hashCode * 59 + PrimarytypesRestrictions.GetHashCode(); } if (IgnoredProperties != null) { hashCode = hashCode * 59 + IgnoredProperties.GetHashCode(); } if (UsedProperties != null) { hashCode = hashCode * 59 + UsedProperties.GetHashCode(); } if (TypeMappings != null) { hashCode = hashCode * 59 + TypeMappings.GetHashCode(); } if (PropertyMappings != null) { hashCode = hashCode * 59 + PropertyMappings.GetHashCode(); } if (CollapseJcrcontentNodes != null) { hashCode = hashCode * 59 + CollapseJcrcontentNodes.GetHashCode(); } return(hashCode); } }
/// <summary> /// Returns true if OrgApacheJackrabbitOakPluginsIndexSolrOsgiOakSolrConfigurationProperties instances are equal /// </summary> /// <param name="other">Instance of OrgApacheJackrabbitOakPluginsIndexSolrOsgiOakSolrConfigurationProperties to be compared</param> /// <returns>Boolean</returns> public bool Equals(OrgApacheJackrabbitOakPluginsIndexSolrOsgiOakSolrConfigurationProperties other) { if (other is null) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return (( PathDescField == other.PathDescField || PathDescField != null && PathDescField.Equals(other.PathDescField) ) && ( PathChildField == other.PathChildField || PathChildField != null && PathChildField.Equals(other.PathChildField) ) && ( PathParentField == other.PathParentField || PathParentField != null && PathParentField.Equals(other.PathParentField) ) && ( PathExactField == other.PathExactField || PathExactField != null && PathExactField.Equals(other.PathExactField) ) && ( CatchAllField == other.CatchAllField || CatchAllField != null && CatchAllField.Equals(other.CatchAllField) ) && ( CollapsedPathField == other.CollapsedPathField || CollapsedPathField != null && CollapsedPathField.Equals(other.CollapsedPathField) ) && ( PathDepthField == other.PathDepthField || PathDepthField != null && PathDepthField.Equals(other.PathDepthField) ) && ( CommitPolicy == other.CommitPolicy || CommitPolicy != null && CommitPolicy.Equals(other.CommitPolicy) ) && ( Rows == other.Rows || Rows != null && Rows.Equals(other.Rows) ) && ( PathRestrictions == other.PathRestrictions || PathRestrictions != null && PathRestrictions.Equals(other.PathRestrictions) ) && ( PropertyRestrictions == other.PropertyRestrictions || PropertyRestrictions != null && PropertyRestrictions.Equals(other.PropertyRestrictions) ) && ( PrimarytypesRestrictions == other.PrimarytypesRestrictions || PrimarytypesRestrictions != null && PrimarytypesRestrictions.Equals(other.PrimarytypesRestrictions) ) && ( IgnoredProperties == other.IgnoredProperties || IgnoredProperties != null && IgnoredProperties.Equals(other.IgnoredProperties) ) && ( UsedProperties == other.UsedProperties || UsedProperties != null && UsedProperties.Equals(other.UsedProperties) ) && ( TypeMappings == other.TypeMappings || TypeMappings != null && TypeMappings.Equals(other.TypeMappings) ) && ( PropertyMappings == other.PropertyMappings || PropertyMappings != null && PropertyMappings.Equals(other.PropertyMappings) ) && ( CollapseJcrcontentNodes == other.CollapseJcrcontentNodes || CollapseJcrcontentNodes != null && CollapseJcrcontentNodes.Equals(other.CollapseJcrcontentNodes) )); }